rubocop-migration 0.1.1 → 0.3.2

data/lib/rubocop/cop/migration/add_index_concurrently.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Use `algorithm: :concurrently` on adding indexes to existing tables in PostgreSQL.
+      #
+      # To avoid blocking writes.
+      #
+      # @safety
+      #   Only meaningful in PostgreSQL.
+      #
+      # @example
+      #   # bad
+      #   class AddIndexToUsersName < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_index :users, :name
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddIndexToUsersNameConcurrently < ActiveRecord::Migration[7.0]
+      #     disable_ddl_transaction!
+      #
+      #     def change
+      #       add_index :users, :name, algorithm: :concurrently
+      #     end
+      #   end
+      class AddIndexConcurrently < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::RuboCop::Migration::CopConcerns::DisableDdlTransaction
+
+        MSG = 'Use `algorithm: :concurrently` on adding indexes to existing tables in PostgreSQL.'
+
+        RESTRICT_ON_SEND = %i[
+          add_index
+          index
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless bad?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method add_index?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_index?, <<~PATTERN
+          (send
+            nil?
+            :add_index
+            _
+            _
+            ...
+          )
+        PATTERN
+
+        # @!method add_index_concurrently?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_index_concurrently?, <<~PATTERN
+          (send
+            nil?
+            :add_index
+            _
+            _
+            (hash
+              <
+                (pair
+                  (sym :algorithm)
+                  (sym :concurrently)
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @!method index?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :index?, <<~PATTERN
+          (send
+            lvar
+            :index
+            _
+            ...
+          )
+        PATTERN
+
+        # @!method index_concurrently?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :index_concurrently?, <<~PATTERN
+          (send
+            lvar
+            :index
+            _
+            (hash
+              <
+                (pair
+                  (sym :algorithm)
+                  (sym :concurrently)
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          insert_disable_ddl_transaction(corrector, node) unless within_disable_ddl_transaction?(node)
+          insert_algorithm_option(corrector, node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          case node.method_name
+          when :add_index
+            add_index?(node) && !add_index_concurrently?(node)
+          when :index
+            index?(node) && in_change_table?(node) && !index_concurrently?(node)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def in_change_table?(node)
+          node.each_ancestor(:block).first&.method?(:change_table)
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def insert_algorithm_option(
+          corrector,
+          node
+        )
+          target_node = node.last_argument
+          target_node = target_node.pairs.last if target_node.hash_type?
+          corrector.insert_after(
+            target_node,
+            ', algorithm: :concurrently'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/add_index_duplicate.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'rubocop/rails/schema_loader'
+require 'rubocop/rails/schema_loader/schema'
+
+module RuboCop
+  module Cop
+    module Migration
+      # Avoid adding duplicate indexes.
+      #
+      # @safety
+      #   This cop tries to find existing indexes from db/schema.rb, but it cannnot be found.
+      #
+      # @example
+      #   # bad
+      #   class AddIndexToUsersNameAndEmail < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_index :users, %w[name index]
+      #     end
+      #   end
+      #
+      #   class AddIndexToUsersName < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_index :users, :name
+      #     end
+      #   end
+      class AddIndexDuplicate < RuboCop::Cop::Base
+        MSG = 'Avoid adding duplicate indexes.'
+
+        RESTRICT_ON_SEND = %i[
+          add_index
+          index
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless bad?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        # @!method add_index?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_index?, <<~PATTERN
+          (send
+            nil?
+            :add_index
+            ...
+          )
+        PATTERN
+
+        # @!method index?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :index?, <<~PATTERN
+          (send
+            lvar
+            :index
+            ...
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def adding_duplicated_index?(node)
+          indexed_column_names = indexed_column_names_from(node)
+          return false unless indexed_column_names
+
+          table_name = table_name_from(node)
+          return false unless table_name
+
+          existing_indexes_for(table_name).any? do |existing_index_column_names|
+            leftmost_match?(
+              haystack: existing_index_column_names,
+              needle: indexed_column_names
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          return false unless target_method?(node)
+
+          adding_duplicated_index?(node)
+        end
+
+        # @param table_name [String]
+        # @return [Array<String>]
+        def existing_indexes_for(table_name)
+          return [] unless schema
+
+          table = schema.table_by(name: table_name)
+          return [] unless table
+
+          table.indices.map do |index|
+            index.columns.map(&:to_s)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Array<String>, nil]
+        def indexed_column_names_from(node)
+          indexed_columns_node = indexed_columns_node_from(node)
+          case indexed_columns_node&.type
+          when :array
+            indexed_columns_node.children.map(&:value).map(&:to_s)
+          when :str, :sym
+            [indexed_columns_node.value.to_s]
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node, nil]
+        def indexed_columns_node_from(node)
+          case node.method_name
+          when :add_index
+            node.arguments[1]
+          when :index
+            node.arguments[0]
+          end
+        end
+
+        # @param haystack [Array<String>]
+        # @param needle [Array<String>]
+        # @return [Boolean]
+        def leftmost_match?(
+          haystack:,
+          needle:
+        )
+          haystack.join(',').start_with?(needle.join(','))
+        end
+
+        # @return [RuboCop::Rails::SchemaLoader::Schema, nil]
+        def schema
+          @schema ||= ::RuboCop::Rails::SchemaLoader.load(target_ruby_version)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [String, nil]
+        def table_name_from(node)
+          table_name_value_node = table_name_value_node_from(node)
+          return unless table_name_value_node.respond_to?(:value)
+
+          table_name_value_node.value.to_s
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node, nil]
+        def table_name_value_node_from(node)
+          case node.method_name
+          when :add_index
+            table_name_value_node_from_add_index(node)
+          when :index
+            table_name_value_node_from_index(node)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node, nil]
+        def table_name_value_node_from_add_index(node)
+          node.first_argument
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node, nil]
+        def table_name_value_node_from_index(node)
+          node.each_ancestor(:block).first&.send_node&.first_argument
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def target_method?(node)
+          add_index?(node) || index?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/batch_in_batches.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Use `in_batches` in batch processing.
+      #
+      # For more efficient batch processing.
+      #
+      # @safety
+      #   There are some cases where we should not do that,
+      #   or this type of consideration might be already done in a way that we cannot detect.
+      #
+      # @example
+      #   # bad
+      #   class BackfillSomeColumn < ActiveRecord::Migration[7.0]
+      #     disable_ddl_transaction!
+      #
+      #     def change
+      #       User.update_all(some_column: 'some value')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BackfillSomeColumnToUsers < ActiveRecord::Migration[7.0]
+      #     disable_ddl_transaction!
+      #
+      #     def up
+      #       User.within_in_batches do |relation|
+      #         relation.update_all(some_column: 'some value')
+      #       end
+      #     end
+      #   end
+      class BatchInBatches < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::RuboCop::Migration::CopConcerns::BatchProcessing
+
+        MSG = 'Use `in_batches` in batch processing.'
+
+        RESTRICT_ON_SEND = %i[
+          delete_all
+          update_all
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless wrong?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          range = node.location.selector.with(
+            end_pos: node.location.expression.end_pos
+          )
+          corrector.replace(
+            range,
+            <<~TEXT.chomp
+              in_batches do |relation|
+                relation.#{range.source}
+              end
+            TEXT
+          )
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Boolean]
+        def within_in_batches?(node)
+          node.each_ancestor(:block).any? do |ancestor|
+            ancestor.method?(:in_batches)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def wrong?(node)
+          batch_processing?(node) &&
+            !within_in_batches?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/batch_in_transaction.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Disable transaction in batch processing.
+      #
+      # To avoid locking the table.
+      #
+      # @safety
+      #   There are some cases where transaction is really needed.
+      #
+      # @example
+      #   # bad
+      #   class AddSomeColumnToUsersThenBackfillSomeColumn < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_column :users, :some_column, :text
+      #       User.update_all(some_column: 'some value')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_column :users, :some_column, :text
+      #     end
+      #   end
+      #
+      #   class BackfillSomeColumnToUsers < ActiveRecord::Migration[7.0]
+      #     disable_ddl_transaction!
+      #
+      #     def up
+      #       User.unscoped.in_batches do |relation|
+      #         relation.update_all(some_column: 'some value')
+      #         sleep(0.01)
+      #       end
+      #     end
+      #   end
+      class BatchInTransaction < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::RuboCop::Migration::CopConcerns::BatchProcessing
+        include ::RuboCop::Migration::CopConcerns::DisableDdlTransaction
+
+        MSG = 'Disable transaction in batch processing.'
+
+        RESTRICT_ON_SEND = %i[
+          delete_all
+          update_all
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless wrong?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          insert_disable_ddl_transaction(corrector, node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def wrong?(node)
+          batch_processing?(node) &&
+            !within_disable_ddl_transaction?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/batch_with_throttling.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Use throttling in batch processing.
+      #
+      # @safety
+      #   There are some cases where we should not do throttling,
+      #   or the throttling might be already done in a way that we cannot detect.
+      #
+      # @example
+      #   # bad
+      #   class BackfillSomeColumn < ActiveRecord::Migration[7.0]
+      #     disable_ddl_transaction!
+      #
+      #     def change
+      #       User.in_batches do |relation|
+      #         relation.update_all(some_column: 'some value')
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BackfillSomeColumnToUsers < ActiveRecord::Migration[7.0]
+      #     disable_ddl_transaction!
+      #
+      #     def up
+      #       User.in_batches do |relation|
+      #         relation.update_all(some_column: 'some value')
+      #         sleep(0.01)
+      #       end
+      #     end
+      #   end
+      class BatchWithThrottling < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::RuboCop::Migration::CopConcerns::BatchProcessing
+
+        MSG = 'Use throttling in batch processing.'
+
+        RESTRICT_ON_SEND = %i[
+          delete_all
+          update_all
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless wrong?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method sleep?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :sleep?, <<~PATTERN
+          (send
+            nil?
+            :sleep
+            ...
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          corrector.insert_after(
+            node,
+            "\n#{' ' * node.location.column}sleep(0.01)"
+          )
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Boolean]
+        def in_block?(node)
+          node.parent&.block_type? ||
+            (node.parent&.begin_type? && node.parent.parent&.block_type?)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def with_throttling?(node)
+          (node.left_siblings + node.right_siblings).any? do |sibling|
+            sleep?(sibling)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def wrong?(node)
+          batch_processing?(node) &&
+            in_block?(node) &&
+            !with_throttling?(node)
+        end
+      end
+    end
+  end
+end