rubocop-migration 0.1.1 → 0.3.2

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,128 @@
+# 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
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return if in_second_migration?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method parse_table_name_and_column_name(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Array<Symbol>, nil]
+        def_node_matcher :parse_table_name_and_column_name, <<~PATTERN
+          (send
+            nil?
+            _
+            ({str sym} $_)
+            ({str sym} $_)
+            ...
+          )
+        PATTERN
+
+        # @!method remove_check_constraint?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :remove_check_constraint?, <<~PATTERN
+          (send nil? :remove_check_constraint ...)
+        PATTERN
+
+        # @!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
+        )
+          table_name, column_name = parse_table_name_and_column_name(node)
+          corrector.replace(
+            node,
+            format(
+              "add_check_constraint :%<table>s, '%<column>s IS NOT NULL', name: '%<constraint>s', validate: false",
+              column: column_name,
+              constraint: "#{table_name}_#{column_name}_is_not_null",
+              table: table_name
+            )
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def called_after_validate_constraint?(node)
+          node.left_siblings.any? do |sibling|
+            validate_constraint?(sibling)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def called_before_remove_check_constraint?(node)
+          node.right_siblings.any? do |sibling|
+            remove_check_constraint?(sibling)
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def in_second_migration?(node)
+          called_after_validate_constraint?(node) ||
+            called_before_remove_check_constraint?(node)
+        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

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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module Migration
+      # Make sure the column is already ignored by the running app before removing it.
+      #
+      # Active Record caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
+      #
+      # @safety
+      #   The logic to check if it is included in `ignored_columns` may fail.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #   end
+      #
+      #   class RemoveUsersSomeColumn < ActiveRecord::Migration[7.0]
+      #     def change
+      #       remove_column :users, :some_column
+      #     end
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     self.ignored_columns += %w[some_column]
+      #   end
+      #
+      #   class RemoveUsersSomeColumn < ActiveRecord::Migration[7.0]
+      #     def change
+      #       remove_column :users, :some_column
+      #     end
+      #   end
+      class RemoveColumn < RuboCop::Cop::Base
+        MSG = 'Make sure the column is already ignored by the running app before removing it.'
+
+        RESTRICT_ON_SEND = %i[
+          remove_column
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless bad?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        # @!method ignored_columns?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :ignored_columns?, <<~PATTERN
+          (send
+            self
+            :ignored_columns
+            ...
+          )
+        PATTERN
+
+        # @!method remove_column?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :remove_column?, <<~PATTERN
+          (send
+            nil?
+            :remove_column
+            ...
+          )
+        PATTERN
+
+        # @!method ignored_column_nodes_from(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<String, Symbol>, nil]
+        def_node_matcher :ignored_column_nodes_from, <<~PATTERN
+          `{
+            (op_asgn
+              (send
+                self
+                :ignored_columns
+                ...
+              )
+              :+
+              (array
+                ({str sym} $_)*
+              )
+            )
+
+            (send
+              self
+              :ignored_columns=
+              (array
+                ({str sym} $_)*
+              )
+            )
+          }
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          remove_column?(node) &&
+            !ignored?(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [String, nil]
+        def find_column_name_from(node)
+          node.arguments[1].value&.to_s
+        end
+
+        # @param table_name [String]
+        # @return [Array<String>]
+        def find_ignored_column_names_from(table_name)
+          pathname = model_pathname_from(
+            singularize(table_name)
+          )
+          return [] unless pathname.exist?
+
+          ignored_column_nodes = ignored_column_nodes_from(
+            parse(
+              content: pathname.read,
+              path: pathname.to_s
+            )
+          )
+          return [] unless ignored_column_nodes
+
+          ignored_column_nodes.map(&:to_s)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [String, nil]
+        def find_table_name_from(node)
+          node.arguments[0].value&.to_s
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def ignored?(node)
+          find_ignored_column_names_from(
+            find_table_name_from(node)
+          ).include?(
+            find_column_name_from(node)
+          )
+        end
+
+        # @param snake_cased_model_name [String]
+        # @return [Pathname]
+        def model_pathname_from(snake_cased_model_name)
+          ::Pathname.new("app/models/#{snake_cased_model_name}.rb")
+        end
+
+        # @param content [String]
+        # @param path [String]
+        # @return [RuboCop::AST::Node]
+        def parse(
+          content:,
+          path:
+        )
+          Parser.call(
+            content: content,
+            path: path,
+            target_ruby_version: target_ruby_version
+          )
+        end
+
+        # @param plural [String]
+        # @return [String]
+        def singularize(plural)
+          ::ActiveSupport::Inflector.singularize(plural)
+        end
+
+        class Parser
+          class << self
+            # @param content [String]
+            # @param path [String]
+            # @param target_ruby_version [#to_s]
+            # @return [RuboCop::AST::Node]
+            def call(
+              content:,
+              path:,
+              target_ruby_version:
+            )
+              new(
+                content: content,
+                path: path,
+                target_ruby_version: target_ruby_version
+              ).call
+            end
+          end
+
+          # @param content [String]
+          # @param path [String]
+          # @param target_ruby_version [#to_s]
+          def initialize(
+            content:,
+            path:,
+            target_ruby_version:
+          )
+            @content = content
+            @path = path
+            @target_ruby_version = target_ruby_version
+          end
+
+          # @return [RuboCop::AST::Node]
+          def call
+            parser.parse(buffer)
+          end
+
+          private
+
+          # @return [Parser::Source::Buffer]
+          def buffer
+            ::Parser::Source::Buffer.new(
+              @path,
+              source: @content
+            )
+          end
+
+          # @return [RuboCop::AST::Builder]
+          def builder
+            ::RuboCop::AST::Builder.new
+          end
+
+          def parser
+            parser_class.new(builder)
+          end
+
+          # @return [Class]
+          def parser_class
+            ::Parser.const_get(parser_class_name)
+          end
+
+          # @return [String]
+          def parser_class_name
+            "Ruby#{@target_ruby_version.to_s.delete('.')}"
+          end
+        end
+      end
+    end
+  end
+end