rubocop-rails 2.15.2 → 2.16.1

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

@@ -81,11 +81,7 @@ module RuboCop
         end
 
         def offense_message(method_name)
-          format(
-            MSG,
-            bad_method: method_name,
-            good_method: convert_good_method(method_name)
-          )
+          format(MSG, bad_method: method_name, good_method: convert_good_method(method_name))
         end
 
         def convert_good_method(bad_method)

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

@@ -34,8 +34,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not assign `%<method_name>s` to constants as it ' \
-              'will be evaluated only once.'
+        MSG = 'Do not assign `%<method_name>s` to constants as it will be evaluated only once.'
         RELATIVE_DATE_METHODS = %i[since from_now after ago until before yesterday tomorrow].to_set.freeze
 
         def on_casgn(node)
@@ -77,9 +76,7 @@ module RuboCop
           return unless scope.nil?
 
           indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
+          new_code = ["def self.#{const_name.downcase}", "#{indent}#{value.source}", 'end'].join("\n#{indent}")
 
           corrector.replace(node.source_range, new_code)
         end

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

@@ -23,8 +23,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MSG = 'Use `request.%<prefer>s` instead of ' \
-              '`request.%<current>s`.'
+        MSG = 'Use `request.%<prefer>s` instead of `request.%<current>s`.'
         RESTRICT_ON_SEND = %i[referer referrer].freeze
 
         def_node_matcher :referer?, <<~PATTERN

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

@@ -229,6 +229,8 @@ module RuboCop
           check_change_table_node(node.send_node, node.body)
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_irreversible_schema_statement_node(node)
@@ -240,10 +242,7 @@ module RuboCop
         def check_drop_table_node(node)
           drop_table_call(node) do
             unless node.parent.block_type? || node.last_argument.block_pass_type?
-              add_offense(
-                node,
-                message: format(MSG, action: 'drop_table(without block)')
-              )
+              add_offense(node, message: format(MSG, action: 'drop_table(without block)'))
             end
           end
         end
@@ -251,22 +250,12 @@ module RuboCop
         def check_reversible_hash_node(node)
           return if reversible_change_table_call?(node)
 
-          add_offense(
-            node,
-            message: format(
-              MSG, action: "#{node.method_name}(without :from and :to)"
-            )
-          )
+          add_offense(node, message: format(MSG, action: "#{node.method_name}(without :from and :to)"))
         end
 
         def check_remove_column_node(node)
           remove_column_call(node) do |args|
-            if args.to_a.size < 3
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_column(without type)')
-              )
-            end
+            add_offense(node, message: format(MSG, action: 'remove_column(without type)')) if args.to_a.size < 3
           end
         end
 
@@ -295,10 +284,7 @@ module RuboCop
             unless all_hash_key?(args, :type) && target_rails_version >= 6.1
               action = target_rails_version >= 6.1 ? 'remove_columns(without type)' : 'remove_columns'
 
-              add_offense(
-                node,
-                message: format(MSG, action: action)
-              )
+              add_offense(node, message: format(MSG, action: action))
             end
           end
         end
@@ -306,18 +292,14 @@ module RuboCop
         def check_remove_index_node(node)
           remove_index_call(node) do |args|
             if args.hash_type? && !all_hash_key?(args, :column)
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_index(without column)')
-              )
+              add_offense(node, message: format(MSG, action: 'remove_index(without column)'))
             end
           end
         end
 
         def check_change_table_offense(receiver, node)
           method_name = node.method_name
-          return if receiver != node.receiver &&
-                    reversible_change_table_call?(node)
+          return if receiver != node.receiver && reversible_change_table_call?(node)
 
           action = if method_name == :remove
                      target_rails_version >= 6.1 ? 't.remove (without type)' : 't.remove'
@@ -325,10 +307,7 @@ module RuboCop
                      "change_table(with #{method_name})"
                    end
 
-          add_offense(
-            node,
-            message: format(MSG, action: action)
-          )
+          add_offense(node, message: format(MSG, action: action))
         end
 
         def reversible_change_table_call?(node)
@@ -353,9 +332,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.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
           end
         end
 

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

@@ -45,8 +45,7 @@ module RuboCop
       class ReversibleMigrationMethodDefinition < Base
         include MigrationsHelper
 
-        MSG = 'Migrations must contain either a `change` method, or ' \
-              'both an `up` and a `down` method.'
+        MSG = 'Migrations must contain either a `change` method, or both an `up` and a `down` method.'
 
         def_node_matcher :change_method?, <<~PATTERN
           `(def :change (args) _)

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

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Use `Rails.root` IO methods instead of passing it to `File`.
+      #
+      # `Rails.root` is an instance of `Pathname`
+      # so we can apply many IO methods directly.
+      #
+      # This cop works best when used together with
+      # `Style/FileRead`, `Style/FileWrite` and `Rails/RootJoinChain`.
+      #
+      # @safety
+      #   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
+      #   # bad
+      #   File.open(Rails.root.join('db', 'schema.rb'))
+      #   File.open(Rails.root.join('db', 'schema.rb'), 'w')
+      #   File.read(Rails.root.join('db', 'schema.rb'))
+      #   File.binread(Rails.root.join('db', 'schema.rb'))
+      #   File.write(Rails.root.join('db', 'schema.rb'), content)
+      #   File.binwrite(Rails.root.join('db', 'schema.rb'), content)
+      #
+      #   # good
+      #   Rails.root.join('db', 'schema.rb').open
+      #   Rails.root.join('db', 'schema.rb').open('w')
+      #   Rails.root.join('db', 'schema.rb').read
+      #   Rails.root.join('db', 'schema.rb').binread
+      #   Rails.root.join('db', 'schema.rb').write(content)
+      #   Rails.root.join('db', 'schema.rb').binwrite(content)
+      #
+      class RootPathnameMethods < Base
+        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
+
+        FILE_METHODS = %i[
+          atime
+          basename
+          binread
+          binwrite
+          birthtime
+          blockdev?
+          chardev?
+          chmod
+          chown
+          ctime
+          delete
+          directory?
+          dirname
+          empty?
+          executable?
+          executable_real?
+          exist?
+          expand_path
+          extname
+          file?
+          fnmatch
+          fnmatch?
+          ftype
+          grpowned?
+          join
+          lchmod
+          lchown
+          lstat
+          mtime
+          open
+          owned?
+          pipe?
+          read
+          readable?
+          readable_real?
+          readlines
+          readlink
+          realdirpath
+          realpath
+          rename
+          setgid?
+          setuid?
+          size
+          size?
+          socket?
+          split
+          stat
+          sticky?
+          symlink?
+          sysopen
+          truncate
+          unlink
+          utime
+          world_readable?
+          world_writable?
+          writable?
+          writable_real?
+          write
+          zero?
+        ].to_set.freeze
+
+        FILE_TEST_METHODS = %i[
+          blockdev?
+          chardev?
+          directory?
+          empty?
+          executable?
+          executable_real?
+          exist?
+          file?
+          grpowned?
+          owned?
+          pipe?
+          readable?
+          readable_real?
+          setgid?
+          setuid?
+          size
+          size?
+          socket?
+          sticky?
+          symlink?
+          world_readable?
+          world_writable?
+          writable?
+          writable_real?
+          zero?
+        ].to_set.freeze
+
+        FILE_UTILS_METHODS = %i[chmod chown mkdir mkpath rmdir rmtree].to_set.freeze
+
+        RESTRICT_ON_SEND = (DIR_METHODS + FILE_METHODS + FILE_TEST_METHODS + FILE_UTILS_METHODS).to_set.freeze
+
+        def_node_matcher :pathname_method, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Dir) $DIR_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 ...)
+        PATTERN
+
+        def_node_matcher :rails_root_pathname?, <<~PATTERN
+          {
+            $#rails_root?
+            (send $#rails_root? :join ...)
+          }
+        PATTERN
+
+        # @!method rails_root?(node)
+        def_node_matcher :rails_root?, <<~PATTERN
+          (send (const {nil? cbase} :Rails) {:root :public_path})
+        PATTERN
+
+        def on_send(node)
+          evidence(node) do |method, path, args, rails_root|
+            add_offense(node, message: format(MSG, method: method, rails_root: rails_root.source)) do |corrector|
+              if dir_glob?(node)
+                replacement = build_path_glob(path, method)
+              else
+                replacement = "#{path.source}.#{method}"
+                replacement += "(#{args.map(&:source).join(', ')})" unless args.empty?
+              end
+
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def evidence(node)
+          return if node.method?(:open) && node.parent&.send_type?
+          return unless (method, path, args = pathname_method(node)) && (rails_root = rails_root_pathname?(path))
+
+          yield(method, path, args, rails_root)
+        end
+
+        def build_path_glob(path, method)
+          receiver = range_between(path.loc.expression.begin_pos, path.children.first.loc.selector.end_pos).source
+
+          argument = if path.arguments.one?
+                       path.first_argument.source
+                     else
+                       join_arguments(path.arguments)
+                     end
+
+          "#{receiver}.#{method}(#{argument})"
+        end
+
+        def include_interpolation?(arguments)
+          arguments.any? do |argument|
+            argument.children.any? { |child| child.respond_to?(:begin_type?) && child.begin_type? }
+          end
+        end
+
+        def join_arguments(arguments)
+          quote = include_interpolation?(arguments) ? '"' : "'"
+          joined_arguments = arguments.map(&:value).join('/')
+
+          "#{quote}#{joined_arguments}#{quote}"
+        end
+      end
+    end
+  end
+end

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

@@ -31,9 +31,7 @@ module RuboCop
       class SafeNavigationWithBlank < Base
         extend AutoCorrector
 
-        MSG =
-          'Avoid calling `blank?` with the safe navigation operator ' \
-          'in conditionals.'
+        MSG = 'Avoid calling `blank?` with the safe navigation operator in conditionals.'
 
         def_node_matcher :safe_navigation_blank_in_conditional?, <<~PATTERN
           (if $(csend ... :blank?) ...)

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

@@ -121,18 +121,12 @@ module RuboCop
         include NegativeConditional
         extend AutoCorrector
 
-        MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
-              'value is not checked.'
-        CREATE_MSG = (MSG +
-                      ' Or check `persisted?` on model returned from ' \
-                      '`%<current>s`.').freeze
-        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is ' \
-                                 'always truthy.'
-
-        CREATE_PERSIST_METHODS = %i[create create_or_find_by
-                                    first_or_create find_or_create_by].freeze
-        MODIFY_PERSIST_METHODS = %i[save
-                                    update update_attributes destroy].freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return value is not checked.'
+        CREATE_MSG = "#{MSG} Or check `persisted?` on model returned from `%<current>s`."
+        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is always truthy.'
+
+        CREATE_PERSIST_METHODS = %i[create create_or_find_by first_or_create find_or_create_by].freeze
+        MODIFY_PERSIST_METHODS = %i[save update update_attributes destroy].freeze
         RESTRICT_ON_SEND = (CREATE_PERSIST_METHODS + MODIFY_PERSIST_METHODS).freeze
 
         def self.joining_forces
@@ -244,8 +238,7 @@ module RuboCop
           parent = node.parent
           return false unless parent
 
-          operator_or_single_negative?(parent) ||
-            (conditional?(parent) && node == parent.condition)
+          operator_or_single_negative?(parent) || (conditional?(parent) && node == parent.condition)
         end
 
         def operator_or_single_negative?(node)
@@ -294,9 +287,7 @@ module RuboCop
         # NameSpace::Const != ::Const
         # Const != NameSpace::Const
         def const_matches?(const, allowed_const)
-          parts = allowed_const.split('::').reverse.zip(
-            const.split('::').reverse
-          )
+          parts = allowed_const.split('::').reverse.zip(const.split('::').reverse)
           parts.all? do |(allowed_part, const_part)|
             allowed_part == const_part.to_s
           end
@@ -335,9 +326,7 @@ module RuboCop
         end
 
         def persist_method?(node, methods = RESTRICT_ON_SEND)
-          methods.include?(node.method_name) &&
-            expected_signature?(node) &&
-            !allowed_receiver?(node)
+          methods.include?(node.method_name) && expected_signature?(node) && !allowed_receiver?(node)
         end
 
         # Check argument signature as no arguments or one hash
@@ -345,8 +334,7 @@ module RuboCop
           !node.arguments? ||
             (node.arguments.one? &&
               node.method_name != :destroy &&
-              (node.first_argument.hash_type? ||
-              !node.first_argument.literal?))
+              (node.first_argument.hash_type? || !node.first_argument.literal?))
         end
       end
     end

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

@@ -44,10 +44,7 @@ module RuboCop
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
 
-        PREFERRED_METHODS = {
-          translate: :t,
-          localize: :l
-        }.freeze
+        PREFERRED_METHODS = { translate: :t, localize: :l }.freeze
 
         RESTRICT_ON_SEND = PREFERRED_METHODS.keys.freeze
 

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

@@ -93,8 +93,7 @@ module RuboCop
         end
 
         def allowed_method?(node)
-          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) &&
-            !node.arguments?
+          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) && !node.arguments?
         end
 
         def forbidden_methods

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

@@ -72,11 +72,7 @@ module RuboCop
         end
 
         def message(node)
-          format(
-            MSG,
-            expect: "#{node.source}#{SQUISH}",
-            current: node.source
-          )
+          format(MSG, expect: "#{node.source}#{SQUISH}", current: node.source)
         end
       end
     end

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

@@ -43,21 +43,17 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` ' \
-              'instead.'
+        MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` instead.'
 
-        MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. ' \
-                         'Use one of %<prefer>s instead.'
+        MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. Use one of %<prefer>s instead.'
 
-        MSG_LOCALTIME = 'Do not use `Time.localtime` without ' \
-                        'offset or zone.'
+        MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
 
         GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
 
         DANGEROUS_METHODS = %i[now local new parse at].freeze
 
-        ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601
-                              jisx0301 rfc3339 httpdate to_i to_f].freeze
+        ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601 jisx0301 rfc3339 httpdate to_i to_f].freeze
 
         TIMEZONE_SPECIFIER = /[A-z]/.freeze
 
@@ -100,13 +96,11 @@ module RuboCop
         # remove redundant `.in_time_zone` from `Time.zone.now.in_time_zone`
         def remove_redundant_in_time_zone(corrector, node)
           time_methods_called = extract_method_chain(node)
-          return unless time_methods_called.include?(:in_time_zone) ||
-                        time_methods_called.include?(:zone)
+          return unless time_methods_called.include?(:in_time_zone) || time_methods_called.include?(:zone)
 
           while node&.send_type?
             if node.children.last == :in_time_zone
-              in_time_zone_with_dot =
-                node.loc.selector.adjust(begin_pos: -1)
+              in_time_zone_with_dot = node.loc.selector.adjust(begin_pos: -1)
               corrector.remove(in_time_zone_with_dot)
             end
             node = node.parent
@@ -144,9 +138,7 @@ module RuboCop
             )
           else
             safe_method_name = safe_method(method_name, node)
-            format(MSG,
-                   current: "#{klass}.#{method_name}",
-                   prefer: "Time.zone.#{safe_method_name}")
+            format(MSG, current: "#{klass}.#{method_name}", prefer: "Time.zone.#{safe_method_name}")
           end
         end
 
@@ -227,10 +219,7 @@ module RuboCop
         end
 
         def acceptable_methods(klass, method_name, node)
-          acceptable = [
-            "`Time.zone.#{safe_method(method_name, node)}`",
-            "`#{klass}.current`"
-          ]
+          acceptable = ["`Time.zone.#{safe_method(method_name, node)}`", "`#{klass}.current`"]
 
           ACCEPTED_METHODS.each do |am|
             acceptable << "`#{klass}.#{method_name}.#{am}`"

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies passing any argument to `#to_s`.
+      #
+      # @safety
+      #   This cop is marked as unsafe because it may detect `#to_s` calls
+      #   that are not related to Active Support implementation.
+      #
+      # @example
+      #
+      #   # bad
+      #   obj.to_s(:delimited)
+      #
+      #   # good
+      #   obj.to_formatted_s(:delimited)
+      #
+      class ToSWithArgument < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `to_formatted_s` instead.'
+
+        RESTRICT_ON_SEND = %i[to_s].freeze
+
+        minimum_target_rails_version 7.0
+
+        def on_send(node)
+          return if node.arguments.empty?
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'to_formatted_s')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies top-level `HashWithIndifferentAccess`.
+      # This has been soft-deprecated since Rails 5.1.
+      #
+      # @example
+      #   # bad
+      #   HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      #   # good
+      #   ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      class TopLevelHashWithIndifferentAccess < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.1
+
+        MSG = 'Avoid top-level `HashWithIndifferentAccess`.'
+
+        # @!method top_level_hash_with_indifferent_access?(node)
+        #   @param [RuboCop::AST::ConstNode] node
+        #   @return [Boolean]
+        def_node_matcher :top_level_hash_with_indifferent_access?, <<~PATTERN
+          (const {nil? cbase} :HashWithIndifferentAccess)
+        PATTERN
+
+        # @param [RuboCop::AST::ConstNode] node
+        def on_const(node)
+          return unless top_level_hash_with_indifferent_access?(node)
+          return if node.parent&.class_type? && node.parent.ancestors.any?(&:module_type?)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.insert_before(node.location.name, 'ActiveSupport::')
+        end
+      end
+    end
+  end
+end

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

@@ -54,11 +54,9 @@ module RuboCop
         NEWLINE = "\n"
         PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
 
-        def_node_matcher :conservative_node_match,
-                         format(PATTERN, type: 'const')
+        def_node_matcher :conservative_node_match, format(PATTERN, type: 'const')
 
-        def_node_matcher :aggressive_node_match,
-                         format(PATTERN, type: '_')
+        def_node_matcher :aggressive_node_match, format(PATTERN, type: '_')
 
         def on_send(node)
           uniq = if style == :conservative
@@ -80,8 +78,7 @@ module RuboCop
         private
 
         def dot_method_with_whitespace(method, node)
-          range_between(dot_method_begin_pos(method, node),
-                        node.loc.selector.end_pos)
+          range_between(dot_method_begin_pos(method, node), node.loc.selector.end_pos)
         end
 
         def dot_method_begin_pos(method, node)

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

@@ -59,9 +59,7 @@ module RuboCop
           add_indices = schema.add_indices_by(table_name: table_name(klass))
 
           (table.indices + add_indices).any? do |index|
-            index.unique &&
-              (index.columns.to_set == names ||
-               include_column_names_in_expression_index?(index, names))
+            index.unique && (index.columns.to_set == names || include_column_names_in_expression_index?(index, names))
           end
         end