rubocop-rails 2.20.2 → 2.21.1

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

@@ -74,13 +74,13 @@ module RuboCop
         end
 
         def allowed_method?(node)
-          return unless cop_config['AllowedMethods']
+          return false unless cop_config['AllowedMethods']
 
           cop_config['AllowedMethods'].include?(node.method_name.to_s)
         end
 
         def allowed_receiver?(node)
-          return unless cop_config['AllowedReceivers'] && node.receiver
+          return false unless cop_config['AllowedReceivers'] && node.receiver
 
           cop_config['AllowedReceivers'].include?(node.receiver.source)
         end
@@ -88,7 +88,7 @@ module RuboCop
         # config option `WhiteList` will be deprecated soon
         def whitelisted?(node)
           whitelist_config = cop_config['Whitelist']
-          return unless whitelist_config
+          return false unless whitelist_config
 
           whitelist_config.include?(node.method_name.to_s)
         end

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

@@ -180,6 +180,9 @@ module RuboCop
               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
 
@@ -230,7 +233,7 @@ module RuboCop
         end
 
         def extension_node?(node)
-          node&.str_type? && node.source.start_with?('.')
+          node&.str_type? && node.source.match?(/\A\.[A-Za-z]+/)
         end
       end
     end

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/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
 

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,146 @@
+# 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)
+      class RedundantActiveRecordAllMethod < Base
+        include ActiveRecordHelper
+        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
+
+        def_node_matcher :followed_by_query_method?, <<~PATTERN
+          (send (send _ :all) QUERYING_METHODS ...)
+        PATTERN
+
+        def on_send(node)
+          return unless followed_by_query_method?(node.parent)
+          return if node.receiver.nil? && !inherit_active_record_base?(node)
+
+          range_of_all_method = node.loc.selector
+          add_offense(range_of_all_method) do |collector|
+            collector.remove(range_of_all_method)
+            collector.remove(node.parent.loc.dot)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -307,7 +307,7 @@ module RuboCop
 
         def within_reversible_or_up_only_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
-            (ancestor.block_type? && ancestor.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
+            (ancestor.block_type? && ancestor.method?(:reversible)) || ancestor.method?(:up_only)
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # `Style/FileRead`, `Style/FileWrite` and `Rails/RootJoinChain`.
       #
       # @safety
-      #   This cop is unsafe for autocorrection because `Dir`'s `children`, `each_child`, `entries`, and `glob`
+      #   This cop is unsafe for autocorrection because ``Dir``'s `children`, `each_child`, `entries`, and `glob`
       #   methods return string element, but these methods of `Pathname` return `Pathname` element.
       #
       # @example
@@ -32,13 +32,28 @@ module RuboCop
       #   Rails.root.join('db', 'schema.rb').write(content)
       #   Rails.root.join('db', 'schema.rb').binwrite(content)
       #
-      class RootPathnameMethods < Base
+      class RootPathnameMethods < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
         include RangeHelp
 
         MSG = '`%<rails_root>s` is a `Pathname` so you can just append `#%<method>s`.'
 
-        DIR_METHODS = %i[children delete each_child empty? entries exist? glob mkdir open rmdir unlink].to_set.freeze
+        DIR_GLOB_METHODS = %i[glob].to_set.freeze
+
+        DIR_NON_GLOB_METHODS = %i[
+          children
+          delete
+          each_child
+          empty?
+          entries
+          exist?
+          mkdir
+          open
+          rmdir
+          unlink
+        ].to_set.freeze
+
+        DIR_METHODS = (DIR_GLOB_METHODS + DIR_NON_GLOB_METHODS).freeze
 
         FILE_METHODS = %i[
           atime
@@ -134,7 +149,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = (DIR_METHODS + FILE_METHODS + FILE_TEST_METHODS + FILE_UTILS_METHODS).to_set.freeze
 
-        def_node_matcher :pathname_method, <<~PATTERN
+        # @!method pathname_method_for_ruby_2_5_or_higher(node)
+        def_node_matcher :pathname_method_for_ruby_2_5_or_higher, <<~PATTERN
           {
             (send (const {nil? cbase} :Dir) $DIR_METHODS $_ $...)
             (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
@@ -143,6 +159,16 @@ module RuboCop
           }
         PATTERN
 
+        # @!method pathname_method_for_ruby_2_4_or_lower(node)
+        def_node_matcher :pathname_method_for_ruby_2_4_or_lower, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Dir) $DIR_NON_GLOB_METHODS $_ $...)
+            (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
+            (send (const {nil? cbase} :FileTest) $FILE_TEST_METHODS $_ $...)
+            (send (const {nil? cbase} :FileUtils) $FILE_UTILS_METHODS $_ $...)
+          }
+        PATTERN
+
         def_node_matcher :dir_glob?, <<~PATTERN
           (send
             (const {cbase nil?} :Dir) :glob ...)
@@ -183,6 +209,14 @@ module RuboCop
           yield(method, path, args, rails_root)
         end
 
+        def pathname_method(node)
+          if target_ruby_version >= 2.5
+            pathname_method_for_ruby_2_5_or_higher(node)
+          else
+            pathname_method_for_ruby_2_4_or_lower(node)
+          end
+        end
+
         def build_path_glob_replacement(path, method)
           receiver = range_between(path.source_range.begin_pos, path.children.first.loc.selector.end_pos).source
 

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

@@ -188,7 +188,7 @@ module RuboCop
         end
 
         def persisted_referenced?(assignment)
-          return unless assignment.referenced?
+          return false unless assignment.referenced?
 
           assignment.variable.references.any? do |reference|
             call_to_persisted?(reference.node.parent)
@@ -298,7 +298,7 @@ module RuboCop
 
           node = assignable_node(node)
           method, sibling_index = find_method_with_sibling_index(node.parent)
-          return unless method && (method.def_type? || method.block_type?)
+          return false unless method && (method.def_type? || method.block_type?)
 
           method.children.size == node.sibling_index + sibling_index
         end

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

@@ -74,17 +74,25 @@ module RuboCop
         def on_send(node)
           if add_column_without_comment?(node)
             add_offense(node, message: COLUMN_MSG)
-          elsif create_table?(node)
-            if create_table_without_comment?(node)
-              add_offense(node, message: TABLE_MSG)
-            elsif create_table_column_call_without_comment?(node)
-              add_offense(node.parent.body, message: COLUMN_MSG)
-            end
+          elsif create_table_without_comment?(node)
+            add_offense(node, message: TABLE_MSG)
+          elsif create_table_with_block?(node.parent)
+            check_column_within_create_table_block(node.parent.body)
           end
         end
 
         private
 
+        def check_column_within_create_table_block(node)
+          if node.begin_type?
+            node.child_nodes.each do |child_node|
+              add_offense(child_node, message: COLUMN_MSG) if t_column_without_comment?(child_node)
+            end
+          elsif t_column_without_comment?(node)
+            add_offense(node, message: COLUMN_MSG)
+          end
+        end
+
         def add_column_without_comment?(node)
           add_column?(node) && !add_column_with_comment?(node)
         end
@@ -93,10 +101,8 @@ module RuboCop
           create_table?(node) && !create_table_with_comment?(node)
         end
 
-        def create_table_column_call_without_comment?(node)
-          create_table_with_block?(node.parent) &&
-            t_column?(node.parent.body) &&
-            !t_column_with_comment?(node.parent.body)
+        def t_column_without_comment?(node)
+          t_column?(node) && !t_column_with_comment?(node)
         end
       end
     end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for uses of `select(:column_name)` with `map(&:column_name)`.
+      # These can be replaced with `pluck(:column_name)`.
+      #
+      # There also should be some performance improvement since it skips instantiating the model class for matches.
+      #
+      # @safety
+      #   This cop is unsafe because the model might override the attribute getter.
+      #   Additionally, the model's `after_initialize` hooks are skipped when using `pluck`.
+      #
+      # @example
+      #   # bad
+      #   Model.select(:column_name).map(&:column_name)
+      #
+      #   # good
+      #   Model.pluck(:column_name)
+      #
+      class SelectMap < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred_method>s` instead of `select` with `%<map_method>s`.'
+
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def on_send(node)
+          return unless node.first_argument
+
+          column_name = node.first_argument.source.delete_prefix('&:')
+          return unless (select_node = find_select_node(node, column_name))
+
+          offense_range = select_node.loc.selector.begin.join(node.source_range.end)
+          preferred_method = "pluck(:#{column_name})"
+          message = format(MSG, preferred_method: preferred_method, map_method: node.method_name)
+
+          add_offense(offense_range, message: message) do |corrector|
+            autocorrect(corrector, select_node, node, preferred_method)
+          end
+        end
+
+        private
+
+        def find_select_node(node, column_name)
+          node.descendants.detect do |select_candidate|
+            next if !select_candidate.send_type? || !select_candidate.method?(:select)
+
+            match_column_name?(select_candidate, column_name)
+          end
+        end
+
+        def autocorrect(corrector, select_node, node, preferred_method)
+          corrector.remove(select_node.loc.dot.begin.join(select_node.source_range.end))
+          corrector.replace(node.loc.selector.begin.join(node.source_range.end), preferred_method)
+        end
+
+        def match_column_name?(select_candidate, column_name)
+          return false unless select_candidate.arguments.one?
+          return false unless (first_argument = select_candidate.first_argument)
+
+          argument = case select_candidate.first_argument.type
+                     when :sym
+                       first_argument.source.delete_prefix(':')
+                     when :str
+                       first_argument.value if first_argument.respond_to?(:value)
+                     end
+
+          argument == column_name
+        end
+      end
+    end
+  end
+end