rubocop-migration 0.2.0 → 0.4.0

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Avoid changing column type that is in use.
+      #
+      # Changing the type of a column 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.
+      #
+      # Some changes don’t require a table rewrite and are safe in PostgreSQL:
+      #
+      # Type | Safe Changes
+      # --- | ---
+      # `cidr` | Changing to `inet`
+      # `citext` | Changing to `text` if not indexed, changing to `string` with no `:limit` if not indexed
+      # `datetime` | Increasing or removing `:precision`, changing to `timestamptz` when session time zone is UTC in Postgres 12+
+      # `decimal` | Increasing `:precision` at same `:scale`, removing `:precision` and `:scale`
+      # `interval` | Increasing or removing `:precision`
+      # `numeric` | Increasing `:precision` at same `:scale`, removing `:precision` and `:scale`
+      # `string` | Increasing or removing `:limit`, changing to `text`, changing `citext` if not indexed
+      # `text` | Changing to `string` with no `:limit`, changing to `citext` if not indexed
+      # `time` | Increasing or removing `:precision`
+      # `timestamptz` | Increasing or removing `:limit`, changing to `datetime` when session time zone is UTC in Postgres 12+
+      #
+      # And some in MySQL and MariaDB:
+      #
+      # Type | Safe Changes
+      # --- | ---
+      # `string` | Increasing `:limit` from under 255 up to 255, increasing `:limit` from over 255 to the max
+      #
+      # A safer approach is to:
+      #
+      # 1. Create a new column
+      # 2. Write to both columns
+      # 3. Backfill data from the old column to the new column
+      # 4. Move reads from the old column to the new column
+      # 5. Stop writing to the old column
+      # 6. Drop the old column
+      #
+      # @safety
+      #   Only meaningful if the table is in use and the type change is really unsafe as described above.
+      #
+      # @example
+      #   # bad
+      #   class ChangeUsersSomeColumnType < ActiveRecord::Migration[7.0]
+      #     def change
+      #       change_column :users, :some_column, :new_type
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddUsersAnotherColumn < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_column :users, :another_column, :new_type
+      #     end
+      #   end
+      #
+      #   class RemoveUsersSomeColumn < ActiveRecord::Migration[7.0]
+      #     def change
+      #       remove_column :users, :some_column
+      #     end
+      #   end
+      class ChangeColumn < RuboCop::Cop::Base
+        MSG = 'Avoid changing column type that is in use.'
+
+        RESTRICT_ON_SEND = %i[
+          change
+          change_column
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless bad?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        # @!method change?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :change?, <<~PATTERN
+          (send
+            lvar
+            :change
+            ...
+          )
+        PATTERN
+
+        # @!method change_column?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :change_column?, <<~PATTERN
+          (send
+            nil?
+            :change_column
+            ...
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          change?(node) ||
+            change_column?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Avoid simply setting `NOT NULL` constraint on an existing column in PostgreSQL.
+      #
+      # It blocks reads and writes while every row is checked.
+      # In PostgreSQL 12+, you can safely set `NOT NULL` constraint if corresponding check constraint exists.
+      #
+      # @safety
+      #   Only meaningful in PostgreSQL 12+.
+      #
+      # @example
+      #   # bad
+      #   class SetNotNullColumnConstraintToUsersName < ActiveRecord::Migration[7.0]
+      #     def change
+      #       change_column_null :users, :name, false
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SetNotNullCheckConstraintToUsersName < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_check_constraint :users, 'name IS NOT NULL', name: 'users_name_is_not_null', validate: false
+      #     end
+      #   end
+      #
+      #   class ReplaceNotNullConstraintOnUsersName < ActiveRecord::Migration[7.0]
+      #     def change
+      #       validate_constraint :users, name: 'users_name_is_not_null'
+      #       change_column_null :users, :name, false
+      #       remove_check_constraint :users, name: 'users_name_is_not_null'
+      #     end
+      #   end
+      class ChangeColumnNull < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        MSG = 'Avoid simply setting `NOT NULL` constraint on an existing column in PostgreSQL.'
+
+        RESTRICT_ON_SEND = %i[
+          change_column_null
+          change_null
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return if called_with_validate_constraint?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method validate_constraint?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :validate_constraint?, <<~PATTERN
+          (send nil? :validate_constraint ...)
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          case node.method_name
+          when :change_column_null
+            autocorrect_change_column_null(corrector, node)
+          when :change_null
+            autocorrect_change_null(corrector, node)
+          end
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect_change_column_null(
+          corrector,
+          node
+        )
+          corrector.replace(
+            node,
+            format_add_check_constraint(
+              column_name: find_column_name_from_change_column_null(node),
+              table_name: find_table_name_from_change_column_null(node)
+            )
+          )
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect_change_null(
+          corrector,
+          node
+        )
+          corrector.replace(
+            node.location.selector.with(
+              end_pos: node.location.expression.end_pos
+            ),
+            format_check_constraint(
+              column_name: find_column_name_from_change_null(node),
+              table_name: find_table_name_from_change_null(node)
+            )
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def called_with_validate_constraint?(node)
+          case node.method_name
+          when :change_column_null
+            node
+          when :change_null
+            find_ancestor_change_table(node)
+          end.left_siblings.any? do |sibling|
+            validate_constraint?(sibling)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::BlockNode]
+        def find_ancestor_change_table(node)
+          node.each_ancestor(:block).find do |ancestor|
+            ancestor.method?(:change_table)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [String]
+        def find_column_name_from_change_column_null(node)
+          node.arguments[1].value.to_s
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [String]
+        def find_column_name_from_change_null(node)
+          node.arguments[0].value.to_s
+        end
+
+        # @parm node [RuboCop::AST::SendNode]
+        # @return [String]
+        def find_table_name_from_change_column_null(node)
+          node.arguments[0].value.to_s
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [String]
+        def find_table_name_from_change_null(node)
+          find_ancestor_change_table(node).send_node.arguments[0].value.to_s
+        end
+
+        # @param column_name [String]
+        # @param table_name [String]
+        # @return [String]
+        def format_add_check_constraint(
+          column_name:,
+          table_name:
+        )
+          format(
+            'add_check_constraint :%<table_name>s, %<arguments>s',
+            arguments: format_check_constraint_arguments(
+              column_name: column_name,
+              table_name: table_name
+            ),
+            table_name: table_name
+          )
+        end
+
+        # @param column_name [String]
+        # @param table_name [String]
+        # @return [String]
+        def format_check_constraint(
+          column_name:,
+          table_name:
+        )
+          format(
+            'check_constraint %<arguments>s',
+            arguments: format_check_constraint_arguments(
+              column_name: column_name,
+              table_name: table_name
+            )
+          )
+        end
+
+        # @param coumn_name [String]
+        # @param table_name [String]
+        # @return [String]
+        def format_check_constraint_arguments(
+          column_name:,
+          table_name:
+        )
+          format(
+            "'%<column_name>s IS NOT NULL', name: '%<constraint_name>s', validate: false",
+            column_name: column_name,
+            constraint_name: "#{table_name}_#{column_name}_is_not_null"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Create tables without `force: true` option.
+      #
+      # The `force: true` option can drop an existing table.
+      # If you indend to drop an existing table, explicitly call `drop_table` first.
+      #
+      # @example
+      #   # bad
+      #   class CreateUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       create_table :users, force: true
+      #     end
+      #   end
+      #
+      #   # good
+      #   class CreateUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       create_table :users
+      #     end
+      #   end
+      class CreateTableForce < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        MSG = 'Create tables without `force: true` option.'
+
+        RESTRICT_ON_SEND = %i[
+          create_table
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          option_node = option_force_true_from_create_table(node)
+          return unless option_node
+
+          add_offense(option_node) do |corrector|
+            autocorrect(corrector, option_node)
+          end
+        end
+
+        private
+
+        # @!method option_force_true_from_create_table(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::PairNode, nil]
+        def_node_matcher :option_force_true_from_create_table, <<~PATTERN
+          (send
+            nil?
+            :create_table
+            _
+            (hash
+              <
+                $(pair
+                  (sym :force)
+                  true
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::PairNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.location.expression,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Prefer `jsonb` to `json`.
+      #
+      # In PostgreSQL, there is no equality operator for the json column type,
+      # which can cause errors for existing `SELECT DISTINCT` queries in your application.
+      #
+      # @safety
+      #   Only meaningful in PostgreSQL.
+      #
+      # @example
+      #   # bad
+      #   add_column :users, :properties, :json
+      #
+      #   # good
+      #   add_column :users, :properties, :jsonb
+      class Jsonb < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `jsonb` to `json`.'
+
+        RESTRICT_ON_SEND = %i[
+          add_column
+          change
+          change_column
+          json
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          json_range = json_range_from_target_send_node(node)
+          return unless json_range
+
+          add_offense(json_range) do |corrector|
+            corrector.replace(json_range, 'jsonb')
+          end
+        end
+
+        private
+
+        # @!method json_type_node_from_add_column(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::SymNode, nil]
+        def_node_matcher :json_type_node_from_add_column, <<~PATTERN
+          (send
+            nil?
+            _
+            _
+            _
+            $(sym :json)
+          )
+        PATTERN
+        alias json_type_node_from_change_column json_type_node_from_add_column
+
+        # @!method json_type_node_from_change(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::SymNode, nil]
+        def_node_matcher :json_type_node_from_change, <<~PATTERN
+          (send
+            lvar
+            _
+            _
+            $(sym :json)
+          )
+        PATTERN
+
+        # @!method json_type_node_from_json(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::SendNode, nil]
+        def_node_matcher :json_type_node_from_json, <<~PATTERN
+          $(send
+            lvar
+            _
+            ...
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode, RuboCop::AST::SymNode]
+        # @return [void]
+        def autocorrect(
+          corrector,
+          node
+        )
+          corrector.replace(node, 'jsonb')
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::SymNode, nil]
+        def json_node_from_target_send_node(node)
+          case node.method_name
+          when :add_column
+            json_type_node_from_add_column(node)
+          when :change
+            json_type_node_from_change(node)
+          when :change_column
+            json_type_node_from_change_column(node)
+          when :json
+            json_type_node_from_json(node)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode, RuboCop::AST::SymNode]
+        # @return [Parser::Source::Range]
+        def json_range_from_json_node(node)
+          case node.type
+          when :send
+            node.location.selector
+          when :sym
+            node.location.expression.with(
+              begin_pos: node.location.expression.begin_pos + 1
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Parser::Source::Range]
+        def json_range_from_target_send_node(node)
+          json_node = json_node_from_target_send_node(node)
+          return unless json_node
+
+          json_range_from_json_node(json_node)
+        end
+      end
+    end
+  end
+end