rubocop-rails 2.11.2 → 2.19.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks whether the change method of the migration file is
+      # Checks whether the change method of the migration file is
       # reversible.
       #
       # @example
@@ -16,23 +16,15 @@ module RuboCop
       #
       #   # good
       #   def change
-      #     create_table :users do |t|
-      #       t.string :name
+      #     change_table :users do |t|
+      #       t.remove :name, :string
       #     end
       #   end
       #
       #   # good
       #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.column :name, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.remove :name
-      #         end
-      #       end
+      #     create_table :users do |t|
+      #       t.string :name
       #     end
       #   end
       #
@@ -114,21 +106,6 @@ module RuboCop
       #     end
       #   end
       #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.change :price, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.change :price, :integer
-      #         end
-      #       end
-      #     end
-      #   end
-      #
       # @example
       #   # remove_columns
       #
@@ -173,13 +150,13 @@ module RuboCop
       #   def change
       #     remove_index :users, column: :email
       #   end
-      #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
       class ReversibleMigration < Base
+        include MigrationsHelper
+
         MSG = '%<action>s is not reversible.'
 
         def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
-          (send nil? ${:execute :remove_belongs_to} ...)
+          (send nil? ${:change_column :execute} ...)
         PATTERN
 
         def_node_matcher :drop_table_call, <<~PATTERN
@@ -207,7 +184,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless within_change_method?(node)
+          return unless in_migration?(node) && within_change_method?(node)
           return if within_reversible_or_up_only_block?(node)
 
           check_irreversible_schema_statement_node(node)
@@ -220,13 +197,15 @@ module RuboCop
         end
 
         def on_block(node)
-          return unless within_change_method?(node)
+          return unless in_migration?(node) && within_change_method?(node)
           return if within_reversible_or_up_only_block?(node)
           return if node.body.nil?
 
           check_change_table_node(node.send_node, node.body)
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_irreversible_schema_statement_node(node)
@@ -238,10 +217,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
@@ -249,22 +225,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
 
@@ -293,10 +259,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
@@ -304,29 +267,30 @@ 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'
+                   else
+                     "change_table(with #{method_name})"
+                   end
 
-          add_offense(
-            node,
-            message: format(MSG, action: "change_table(with #{method_name})")
-          )
+          add_offense(node, message: format(MSG, action: action))
         end
 
         def reversible_change_table_call?(node)
           case node.method_name
-          when :change, :remove
+          when :change
             false
+          when :remove
+            target_rails_version >= 6.1 && all_hash_key?(node.arguments.last, :type)
           when :change_default, :change_column_default, :change_table_comment,
                :change_column_comment
             all_hash_key?(node.arguments.last, :from, :to)
@@ -343,9 +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.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks whether the migration implements
+      # Checks whether the migration implements
       # either a `change` method or both an `up` and a `down`
       # method.
       #
@@ -43,29 +43,20 @@ module RuboCop
       #     end
       #   end
       class ReversibleMigrationMethodDefinition < Base
-        MSG = 'Migrations must contain either a `change` method, or ' \
-              'both an `up` and a `down` method.'
+        include MigrationsHelper
 
-        def_node_matcher :migration_class?, <<~PATTERN
-          (class
-            (const nil? _)
-            (send
-              (const (const {nil? cbase} :ActiveRecord) :Migration)
-              :[]
-              (float _))
-            _)
-        PATTERN
+        MSG = 'Migrations must contain either a `change` method, or both an `up` and a `down` method.'
 
         def_node_matcher :change_method?, <<~PATTERN
-          [ #migration_class? `(def :change (args) _) ]
+          `(def :change (args) _)
         PATTERN
 
         def_node_matcher :up_and_down_methods?, <<~PATTERN
-          [ #migration_class? `(def :up (args) _) `(def :down (args) _) ]
+          [`(def :up (args) _) `(def :down (args) _)]
         PATTERN
 
         def on_class(node)
-          return if change_method?(node) || up_and_down_methods?(node)
+          return if !migration_class?(node) || change_method?(node) || up_and_down_methods?(node)
 
           add_offense(node)
         end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Use a single `#join` instead of chaining on `Rails.root` or `Rails.public_path`.
+      #
+      # @example
+      #   # bad
+      #   Rails.root.join('db').join('schema.rb')
+      #   Rails.root.join('db').join(migrate).join('migration.rb')
+      #   Rails.public_path.join('path').join('file.pdf')
+      #   Rails.public_path.join('path').join(to).join('file.pdf')
+      #
+      #   # good
+      #   Rails.root.join('db', 'schema.rb')
+      #   Rails.root.join('db', migrate, 'migration.rb')
+      #   Rails.public_path.join('path', 'file.pdf')
+      #   Rails.public_path.join('path', to, 'file.pdf')
+      #
+      class RootJoinChain < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `%<root>s.join(...)` instead of chaining `#join` calls.'
+
+        RESTRICT_ON_SEND = %i[join].to_set.freeze
+
+        # @!method rails_root?(node)
+        def_node_matcher :rails_root?, <<~PATTERN
+          (send (const {nil? cbase} :Rails) {:root :public_path})
+        PATTERN
+
+        # @!method join?(node)
+        def_node_matcher :join?, <<~PATTERN
+          (send _ :join $...)
+        PATTERN
+
+        def on_send(node)
+          evidence(node) do |rails_node, args|
+            add_offense(node, message: format(MSG, root: rails_node.source)) do |corrector|
+              range = range_between(rails_node.loc.selector.end_pos, node.source_range.end_pos)
+              replacement = ".join(#{args.map(&:source).join(', ')})"
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def evidence(node)
+          # Are we at the *end* of the join chain?
+          return if join?(node.parent)
+          # Is there only one join?
+          return if rails_root?(node.receiver)
+
+          all_args = []
+
+          while (args = join?(node))
+            all_args = args + all_args
+            node = node.receiver
+          end
+
+          rails_root?(node) do
+            yield(node, all_args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+# 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|
+              replacement = if dir_glob?(node)
+                              build_path_glob_replacement(path, method)
+                            else
+                              build_path_replacement(path, method, args)
+                            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_replacement(path, method)
+          receiver = range_between(path.source_range.begin_pos, path.children.first.loc.selector.end_pos).source
+
+          argument = path.arguments.one? ? path.first_argument.source : join_arguments(path.arguments)
+
+          "#{receiver}.#{method}(#{argument})"
+        end
+
+        def build_path_replacement(path, method, args)
+          path_replacement = path.source
+          if path.arguments? && !path.parenthesized_call?
+            path_replacement[' '] = '('
+            path_replacement << ')'
+          end
+
+          replacement = "#{path_replacement}.#{method}"
+          replacement += "(#{args.map(&:source).join(', ')})" unless args.empty?
+          replacement
+        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)
+          use_interpolation = false
+
+          joined_arguments = arguments.map do |arg|
+            if arg.respond_to?(:value)
+              arg.value
+            else
+              use_interpolation = true
+              "\#{#{arg.source}}"
+            end
+          end.join('/')
+          quote = enforce_double_quotes? || include_interpolation?(arguments) || use_interpolation ? '"' : "'"
+
+          "#{quote}#{joined_arguments}#{quote}"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Favor `Rails.public_path` over `Rails.root` with `'public'`
+      #
+      # @example
+      #   # bad
+      #   Rails.root.join('public')
+      #   Rails.root.join('public/file.pdf')
+      #   Rails.root.join('public', 'file.pdf')
+      #
+      #   # good
+      #   Rails.public_path
+      #   Rails.public_path.join('file.pdf')
+      #   Rails.public_path.join('file.pdf')
+      #
+      class RootPublicPath < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Rails.public_path`.'
+
+        RESTRICT_ON_SEND = %i[join].to_set.freeze
+
+        PATTERN = %r{\Apublic(/|\z)}.freeze
+
+        def_node_matcher :rails_root_public, <<~PATTERN
+          (send
+            (send
+              $(const {nil? cbase} :Rails) :root) :join
+            (str $#public_path?) $...)
+        PATTERN
+
+        def on_send(node)
+          return unless (rails, maybe_public_path, other_args = rails_root_public(node))
+
+          add_offense(node) do |corrector|
+            first_args = maybe_public_path.gsub(PATTERN, '')
+
+            args = other_args.map(&:source)
+            args.unshift("'#{first_args}'") unless first_args.empty?
+
+            replacement = "#{rails.source}.public_path"
+            replacement += ".join(#{args.join(', ')})" unless args.empty?
+
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def public_path?(string)
+          PATTERN.match?(string)
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop converts usages of `try!` to `&.`. It can also be configured
-      # to convert `try`. It will convert code to use safe navigation.
+      # Converts usages of `try!` to `&.`. It can also be configured
+      # to convert `try`. It will convert code to use safe navigation
+      # if the target Ruby version is set to 2.3+
       #
       # @example ConvertTry: false (default)
       #   # bad
@@ -39,6 +40,9 @@ module RuboCop
       class SafeNavigation < Base
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         MSG = 'Use safe navigation (`&.`) instead of `%<try>s`.'
         RESTRICT_ON_SEND = %i[try try!].freeze
@@ -47,15 +51,6 @@ module RuboCop
           (send _ ${:try :try!} $_ ...)
         PATTERN
 
-        # Monkey patching for `Style/RedundantSelf` of RuboCop core.
-        # rubocop:disable Style/ClassAndModuleChildren
-        class Style::RedundantSelf
-          def self.autocorrect_incompatible_with
-            [Rails::SafeNavigation]
-          end
-        end
-        # rubocop:enable Style/ClassAndModuleChildren
-
         def self.autocorrect_incompatible_with
           [Style::RedundantSelf]
         end
@@ -75,10 +70,10 @@ module RuboCop
 
         def autocorrect(corrector, node)
           method_node, *params = *node.arguments
-          method = method_node.source[1..-1]
+          method = method_node.source[1..]
 
           range = if node.receiver
-                    range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
+                    range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
                   else
                     corrector.insert_before(node, 'self')
                     node

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

@@ -3,12 +3,21 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks to make sure safe navigation isn't used with `blank?` in
+      # Checks to make sure safe navigation isn't used with `blank?` in
       # a conditional.
       #
-      # While the safe navigation operator is generally a good idea, when
-      # checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
-      # do the opposite of what the author intends.
+      # @safety
+      #   While the safe navigation operator is generally a good idea, when
+      #   checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
+      #   do the opposite of what the author intends.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   foo&.blank? #=> nil
+      #   foo.blank? #=> true
+      #   ----
       #
       # @example
       #   # bad
@@ -22,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?) ...)