rubocop-rails 2.0.1 → 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
       #
@@ -90,6 +82,11 @@ module RuboCop
       #     remove_foreign_key :accounts, :branches
       #   end
       #
+      #   # good
+      #   def change
+      #     remove_foreign_key :accounts, to_table: :branches
+      #   end
+      #
       # @example
       #   # change_table
       #
@@ -109,71 +106,106 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # remove_columns
+      #
+      #   # bad
+      #   def change
+      #     remove_columns :users, :name, :email
+      #   end
+      #
       #   # good
       #   def change
       #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.change :price, :string
-      #         end
+      #       dir.up do
+      #         remove_columns :users, :name, :email
+      #       end
       #
-      #         dir.down do
-      #           t.change :price, :integer
-      #         end
+      #       dir.down do
+      #         add_column :users, :name, :string
+      #         add_column :users, :email, :string
       #       end
       #     end
       #   end
       #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
-      class ReversibleMigration < Cop
+      #   # good (Rails >= 6.1, see https://github.com/rails/rails/pull/36589)
+      #   def change
+      #     remove_columns :users, :name, :email, type: :string
+      #   end
+      #
+      # @example
+      #   # remove_index
+      #
+      #   # bad
+      #   def change
+      #     remove_index :users, name: :index_users_on_email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, column: :email
+      #   end
+      class ReversibleMigration < Base
+        include MigrationsHelper
+
         MSG = '%<action>s is not reversible.'
-        IRREVERSIBLE_CHANGE_TABLE_CALLS = %i[
-          change change_default remove
-        ].freeze
 
-        def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
-          (send nil? ${:change_table_comment :execute :remove_belongs_to} ...)
+        def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
+          (send nil? ${:change_column :execute} ...)
         PATTERN
 
-        def_node_matcher :drop_table_call, <<-PATTERN
+        def_node_matcher :drop_table_call, <<~PATTERN
           (send nil? :drop_table ...)
         PATTERN
 
-        def_node_matcher :change_column_default_call, <<-PATTERN
-          (send nil? :change_column_default {[(sym _) (sym _)] (splat _)} $...)
-        PATTERN
-
-        def_node_matcher :remove_column_call, <<-PATTERN
+        def_node_matcher :remove_column_call, <<~PATTERN
           (send nil? :remove_column $...)
         PATTERN
 
-        def_node_matcher :remove_foreign_key_call, <<-PATTERN
+        def_node_matcher :remove_foreign_key_call, <<~PATTERN
           (send nil? :remove_foreign_key _ $_)
         PATTERN
 
-        def_node_matcher :change_table_call, <<-PATTERN
+        def_node_matcher :change_table_call, <<~PATTERN
           (send nil? :change_table $_ ...)
         PATTERN
 
+        def_node_matcher :remove_columns_call, <<~PATTERN
+          (send nil? :remove_columns ... $_)
+        PATTERN
+
+        def_node_matcher :remove_index_call, <<~PATTERN
+          (send nil? :remove_index _ $_)
+        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)
           check_drop_table_node(node)
-          check_change_column_default_node(node)
+          check_reversible_hash_node(node)
           check_remove_column_node(node)
           check_remove_foreign_key_node(node)
+          check_remove_columns_node(node)
+          check_remove_index_node(node)
         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)
@@ -184,59 +216,35 @@ module RuboCop
 
         def check_drop_table_node(node)
           drop_table_call(node) do
-            unless node.parent.block_type?
-              add_offense(
-                node,
-                message: format(MSG, action: 'drop_table(without block)')
-              )
+            unless node.parent.block_type? || node.last_argument.block_pass_type?
+              add_offense(node, message: format(MSG, action: 'drop_table(without block)'))
             end
           end
         end
 
-        def check_change_column_default_node(node)
-          change_column_default_call(node) do |args|
-            unless all_hash_key?(args.last, :from, :to)
-              add_offense(
-                node,
-                message: format(
-                  MSG, action: 'change_column_default(without :from and :to)'
-                )
-              )
-            end
-          end
+        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)"))
         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
 
         def check_remove_foreign_key_node(node)
           remove_foreign_key_call(node) do |arg|
-            if arg.hash_type?
-              add_offense(
-                node,
-                message: format(MSG,
-                                action: 'remove_foreign_key(without table)')
-              )
+            if arg.hash_type? && !all_hash_key?(arg, :to_table)
+              add_offense(node, message: format(MSG, action: 'remove_foreign_key(without table)'))
             end
           end
         end
 
         def check_change_table_node(node, block)
           change_table_call(node) do |arg|
-            if target_rails_version < 4.0
-              add_offense(
-                node,
-                message: format(MSG, action: 'change_table')
-              )
-            elsif block.send_type?
+            if block.send_type?
               check_change_table_offense(arg, block)
             else
               block.each_child_node(:send) do |child_node|
@@ -246,15 +254,49 @@ module RuboCop
           end
         end
 
+        def check_remove_columns_node(node)
+          remove_columns_call(node) do |args|
+            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))
+            end
+          end
+        end
+
+        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)'))
+            end
+          end
+        end
+
         def check_change_table_offense(receiver, node)
           method_name = node.method_name
-          return if receiver != node.receiver &&
-                    !IRREVERSIBLE_CHANGE_TABLE_CALLS.include?(method_name)
+          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
+            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)
+          else
+            true
+          end
         end
 
         def within_change_method?(node)
@@ -265,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
 
@@ -278,7 +318,7 @@ module RuboCop
             key.children.first.to_sym
           end
 
-          hash_keys & keys == keys
+          (hash_keys & keys).sort == keys
         end
       end
     end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks whether the migration implements
+      # either a `change` method or both an `up` and a `down`
+      # method.
+      #
+      # @example
+      #   # bad
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def up
+      #       # up migration
+      #     end
+      #
+      #     # <----- missing down method
+      #   end
+      #
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     # <----- missing up method
+      #
+      #     def down
+      #       # down migration
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def change
+      #       # reversible migration
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def up
+      #       # up migration
+      #     end
+      #
+      #     def down
+      #       # down migration
+      #     end
+      #   end
+      class ReversibleMigrationMethodDefinition < Base
+        include MigrationsHelper
+
+        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) _)
+        PATTERN
+
+        def_node_matcher :up_and_down_methods?, <<~PATTERN
+          [`(def :up (args) _) `(def :down (args) _)]
+        PATTERN
+
+        def on_class(node)
+          return if !migration_class?(node) || change_method?(node) || up_and_down_methods?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+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