sevencop 0.21.0 → 0.22.0

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationBatchInTransaction < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        include ::Sevencop::CopConcerns::BatchProcessing
+        include ::Sevencop::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/sevencop/rails_migration_batch_with_throttling.rb

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

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationChangeColumn < 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/sevencop/rails_migration_change_column_null.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationChangeColumnNull < 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/sevencop/rails_migration_create_table_force.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationCreateTableForce < 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/sevencop/rails_migration_jsonb.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationJsonb < 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