rubocop-rails 2.15.0 → 2.16.0

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

@@ -60,15 +60,6 @@ module RuboCop
 
         MSG = 'Redundant receiver in `with_options`.'
 
-        def_node_matcher :with_options?, <<~PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
         def_node_search :all_block_nodes_in, <<~PATTERN
           (block ...)
         PATTERN
@@ -78,29 +69,40 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
-
-            send_nodes = all_send_nodes_in(body)
-
-            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
-              send_nodes.each do |send_node|
-                receiver = send_node.receiver
-                add_offense(receiver.source_range) do |corrector|
-                  autocorrect(corrector, send_node)
-                end
-              end
+          return unless node.method?(:with_options)
+          return unless (body = node.body)
+          return unless all_block_nodes_in(body).count.zero?
+
+          send_nodes = all_send_nodes_in(body)
+          return unless redundant_receiver?(send_nodes, node)
+
+          send_nodes.each do |send_node|
+            receiver = send_node.receiver
+            add_offense(receiver.source_range) do |corrector|
+              autocorrect(corrector, send_node, node)
             end
           end
         end
 
+        alias on_numblock on_block
+
         private
 
-        def autocorrect(corrector, node)
-          corrector.remove(node.receiver.source_range)
-          corrector.remove(node.loc.dot)
-          corrector.remove(block_argument_range(node))
+        def autocorrect(corrector, send_node, node)
+          corrector.remove(send_node.receiver.source_range)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
+        end
+
+        def redundant_receiver?(send_nodes, node)
+          proc = if node.numblock_type?
+                   ->(n) { n.receiver.lvar_type? && n.receiver.source == '_1' }
+                 else
+                   arg = node.arguments.first
+                   ->(n) { same_value?(arg, n.receiver) }
+                 end
+
+          send_nodes.all?(&proc)
         end
 
         def block_argument_range(node)

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

@@ -34,12 +34,29 @@ 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.lvar_type? && str_assigned?(reflection_class_name)
+
             add_offense(reflection_class_name.loc.expression)
           end
         end
 
         private
 
+        def str_assigned?(reflection_class_name)
+          lvar = reflection_class_name.value.source
+
+          reflection_class_name.ancestors.each do |nodes|
+            return true if nodes.each_child_node(:lvasgn).detect do |node|
+              lhs, rhs = *node
+
+              lhs.to_s == lvar && ALLOWED_REFLECTION_CLASS_TYPES.include?(rhs.type)
+            end
+          end
+
+          false
+        end
+
         def reflection_class_value?(class_value)
           if class_value.send_type?
             !class_value.method?(:to_s) || class_value.receiver&.const_type?

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,175 @@
+# 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`.
+      #
+      # @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
+
+        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 :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|
+              replacement = "#{path.source}.#{method}"
+              replacement += "(#{args.map(&:source).join(', ')})" unless args.empty?
+
+              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
+      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/strip_heredoc.rb

@@ -43,7 +43,7 @@ module RuboCop
 
         def register_offense(node, heredoc)
           add_offense(node) do |corrector|
-            squiggly_heredoc = heredoc.source.sub(/\A<<-?/, '<<~')
+            squiggly_heredoc = heredoc.source.sub(/\A<<(-|~)?/, '<<~')
 
             corrector.replace(heredoc, squiggly_heredoc)
             corrector.remove(node.loc.dot)

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

@@ -22,12 +22,12 @@ module RuboCop
         MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
         RESTRICT_ON_SEND = %i[zone=].freeze
 
-        def_node_matcher :time_zone_assignement?, <<~PATTERN
+        def_node_matcher :time_zone_assignment?, <<~PATTERN
           (send (const nil? :Time) :zone= ...)
         PATTERN
 
         def on_send(node)
-          return unless time_zone_assignement?(node)
+          return unless time_zone_assignment?(node)
 
           add_offense(node)
         end

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

@@ -39,6 +39,7 @@ module RuboCop
             corrector.replace(node.loc.selector, style)
           end
         end
+        alias on_csend on_send
       end
     end
   end