sevencop 0.21.0 → 0.22.0

data/lib/rubocop/cop/sevencop/rails_migration_add_column_with_default_value.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # Add the column without a default value then change the default.
+      #
+      # In earlier versions of Postgres, MySQL, and MariaDB,
+      # adding a column with a default value to an existing table causes the entire table to be rewritten.
+      # During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
+      #
+      # @safety
+      #   Only meaningful in earlier versions of Postgres, MySQL, and MariaDB.
+      #
+      # @example
+      #   # bad
+      #   class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_column :users, :some_column, :string, default: 'some value'
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_column :users, :some_column, :string
+      #       change_column_default :users, :some_column, 'some value'
+      #     end
+      #   end
+      class RailsMigrationAddColumnWithDefaultValue < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include RangeHelp
+        include ::Sevencop::CopConcerns::ColumnTypeMethod
+
+        MSG = 'Add the column without a default value then change the default.'
+
+        RESTRICT_ON_SEND = [
+          :add_column,
+          *COLUMN_TYPE_METHOD_NAMES
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless target_method?(node)
+
+          default_option_node = non_nil_default_option_node_from(node)
+          return unless default_option_node
+
+          add_offense(default_option_node) do |corrector|
+            autocorrect(
+              corrector,
+              default_option_node: default_option_node,
+              send_node: node
+            )
+          end
+        end
+
+        private
+
+        # @!method add_column?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_column?, <<~PATTERN
+          (send
+            nil?
+            :add_column
+            ...
+          )
+        PATTERN
+
+        # @!method column_type_method?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :column_type_method?, <<~PATTERN
+          (send
+            lvar
+            COLUMN_TYPE_METHOD_NAMES
+            ...
+          )
+        PATTERN
+
+        # @!method non_nil_default_option_node_from(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::PairNode, nil]
+        def_node_matcher :non_nil_default_option_node_from, <<~PATTERN
+          (send
+            _
+            _
+            ...
+            (hash
+              <
+                $(pair
+                  (sym :default)
+                  !nil
+                )
+              >
+              ...
+            )
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param default_option_node [RuboCop::AST::PairNode]
+        # @param send_node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          default_option_node:,
+          send_node:
+        )
+          remove_pair(
+            corrector,
+            default_option_node
+          )
+          insert_change_column_default(
+            corrector,
+            default_option_node: default_option_node,
+            send_node: send_node
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::SymNode]
+        def find_column_node_from(node)
+          case node.method_name
+          when :add_column
+            node.arguments[1]
+          else
+            node.first_argument
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::SendNode]
+        def find_insertion_target_node_from(node)
+          case node.method_name
+          when :add_column
+            node
+          else
+            node.each_ancestor(:block).first
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::SymNode]
+        def find_table_node_from(node)
+          case node.method_name
+          when :add_column
+            node.first_argument
+          else
+            node.each_ancestor(:block).first.send_node.first_argument
+          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::Node]
+        # @param string [String]
+        def insert_after_with_same_indentation(
+          corrector,
+          node,
+          string
+        )
+          corrector.insert_after(
+            node,
+            format(
+              "\n%<indentation>s%<string>s",
+              indentation: ' ' * node.location.column,
+              string: string
+            )
+          )
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param default_option_node [RuboCop::AST::PairNode]
+        # @param send_node [RuboCop::AST::SendNode]
+        # @return [void]
+        def insert_change_column_default(
+          corrector,
+          default_option_node:,
+          send_node:
+        )
+          insert_after_with_same_indentation(
+            corrector,
+            find_insertion_target_node_from(send_node),
+            format(
+              'change_column_default %<table>s, %<column>s, %<default>s',
+              column: find_column_node_from(send_node).source,
+              default: default_option_node.value.source,
+              table: find_table_node_from(send_node).source
+            )
+          )
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::Node]
+        # @return [void]
+        def remove_pair(
+          corrector,
+          node
+        )
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.location.expression,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def target_method?(node)
+          add_column?(node) ||
+            (column_type_method?(node) && in_change_table?(node))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sevencop/rails_migration_add_foreign_key.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # Activate foreign key validation in a separate migration in PostgreSQL.
+      #
+      # To avoid blocking writes on both tables.
+      #
+      # @safety
+      #   Only meaningful in PostgreSQL.
+      #
+      # @example
+      #   # bad
+      #   class AddForeignKeyFromArticlesToUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_foreign_key :articles, :users
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddForeignKeyFromArticlesToUsersWithoutValidation < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_foreign_key :articles, :users, validate: false
+      #     end
+      #   end
+      #
+      #   class ActivateForeignKeyValidationFromArticlesToUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       validate_foreign_key :articles, :users
+      #     end
+      #   end
+      class RailsMigrationAddForeignKey < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        MSG = 'Activate foreign key validation in a separate migration in PostgreSQL.'
+
+        RESTRICT_ON_SEND = %i[
+          add_foreign_key
+          add_reference
+        ].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_foreign_key_without_validate_option?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_foreign_key_without_validate_option?, <<~PATTERN
+          (send
+            nil?
+            :add_foreign_key
+            _
+            _
+            (hash
+              (pair
+                !(sym :validate)
+                _
+              )*
+            )?
+          )
+        PATTERN
+
+        # @!method option_validate_true_value_node_from_add_foreign_key(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::PairNode]
+        def_node_matcher :option_validate_true_value_node_from_add_foreign_key, <<~PATTERN
+          (send
+            nil?
+            :add_foreign_key
+            _
+            _
+            (hash
+              <
+                (pair
+                  (sym :validate)
+                  $true
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @!method option_foreign_key_true_node_from_add_reference(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::PairNode]
+        def_node_matcher :option_foreign_key_true_node_from_add_reference, <<~PATTERN
+          (send
+            nil?
+            :add_reference
+            _
+            _
+            (hash
+              <
+                $(pair
+                  (sym :foreign_key)
+                  true
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def add_foreign_key_with_validate_option_true?(node)
+          option_validate_true_value_node_from_add_foreign_key(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def add_reference_with_validate_option_true?(node)
+          option_foreign_key_true_node_from_add_reference(node)
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          if add_foreign_key_without_validate_option?(node)
+            corrector.insert_after(node.last_argument, ', validate: false')
+          elsif add_foreign_key_with_validate_option_true?(node)
+            corrector.replace(
+              option_validate_true_value_node_from_add_foreign_key(node),
+              'false'
+            )
+          elsif add_reference_with_validate_option_true?(node)
+            corrector.remove(
+              range_with_surrounding_comma(
+                range_with_surrounding_space(
+                  option_foreign_key_true_node_from_add_reference(node).location.expression,
+                  side: :left
+                ),
+                :left
+              )
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          add_foreign_key_without_validate_option?(node) ||
+            add_foreign_key_with_validate_option_true?(node) ||
+            add_reference_with_validate_option_true?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sevencop/rails_migration_add_index_concurrently.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationAddIndexConcurrently < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::Sevencop::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/sevencop/rails_migration_batch_in_batches.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationBatchInBatches < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::Sevencop::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