rubocop-migration 0.2.0 → 0.4.0

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Activate a check constraint in a separate migration in PostgreSQL.
+      #
+      # Adding a check constraint without `NOT VALID` blocks reads and writes in Postgres and
+      # blocks writes in MySQL and MariaDB while every row is checked.
+      #
+      # @safety
+      #   Only meaningful in PostgreSQL.
+      #
+      # @example
+      #   # bad
+      #   class AddCheckConstraintToOrdersPrice < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_check_constraint :orders, 'price > 0', name: 'orders_price_positive'
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddCheckConstraintToOrdersPriceWithoutValidation < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_check_constraint :orders, 'price > 0', name: 'orders_price_positive', validate: false
+      #     end
+      #   end
+      #
+      #   class ActivateCheckConstraintOnOrdersPrice < ActiveRecord::Migration[7.0]
+      #     def change
+      #       validate_check_constraint :orders, name: 'orders_price_positive'
+      #     end
+      #   end
+      class AddCheckConstraint < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        MSG = 'Activate a check constraint in a separate migration in PostgreSQL.'
+
+        RESTRICT_ON_SEND = %i[
+          add_check_constraint
+        ].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_check_constraint?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_check_constraint?, <<~PATTERN
+          (send
+            nil?
+            :add_check_constraint
+            ...
+          )
+        PATTERN
+
+        # @!method add_check_constraint_with_validate_false?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :add_check_constraint_with_validate_false?, <<~PATTERN
+          (send
+            nil?
+            :add_check_constraint
+            _
+            _
+            (hash
+              <
+                (pair
+                  (sym :validate)
+                  false
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          target = node.last_argument
+          target = target.pairs.last if target.hash_type?
+          corrector.insert_after(
+            target,
+            ', validate: false'
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          add_check_constraint?(node) &&
+            !add_check_constraint_with_validate_false?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # 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 AddColumnWithDefaultValue < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include RangeHelp
+        include ::RuboCop::Migration::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/migration/add_foreign_key.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # 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 AddForeignKey < 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/migration/add_index_columns_count.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Keep non-unique index columns count less than a specified number.
+      #
+      # Adding a non-unique index with more than three columns rarely improves performance.
+      # Instead, start an index with columns that narrow down the results the most.
+      #
+      # @example
+      #   # bad
+      #   add_index :users, %i[a b c d]
+      #
+      #   # good (`MaxColumnsCount: 3` by default)
+      #   add_index :users, %i[a b c]
+      class AddIndexColumnsCount < RuboCop::Cop::Base
+        RESTRICT_ON_SEND = %i[
+          add_index
+          index
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return if with_unique_option?(node)
+
+          column_names_node = column_names_node_from(node)
+          return unless column_names_node
+
+          column_names_count = columns_count_from(column_names_node)
+          return if column_names_count <= max_columns_count
+
+          add_offense(
+            column_names_node,
+            message: "Keep unique index columns count less than #{max_columns_count}."
+          )
+        end
+
+        private
+
+        # @!method column_names_node_from_add_index(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :column_names_node_from_add_index, <<~PATTERN
+          (send
+            nil?
+            :add_index
+            _
+            $({array | str | sym} ...)
+            ...
+          )
+        PATTERN
+
+        # @!method column_names_node_from_index(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :column_names_node_from_index, <<~PATTERN
+          (send
+            lvar
+            :index
+            $({array | str | sym} ...)
+            ...
+          )
+        PATTERN
+
+        # @!method with_unique_option?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :with_unique_option?, <<~PATTERN
+          (send
+            ...
+            (hash
+              <
+                (pair
+                  (sym :unique)
+                  true
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node, nil]
+        def column_names_node_from(node)
+          case node.method_name
+          when :add_index
+            column_names_node_from_add_index(node)
+          when :index
+            column_names_node_from_index(node)
+          end
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Integer, nil]
+        def columns_count_from(node)
+          case node.type
+          when :array
+            node.values.count
+          when :sym
+            1
+          end
+        end
+
+        # @return [Integer]
+        def max_columns_count
+          cop_config['MaxColumnsCount']
+        end
+      end
+    end
+  end
+end