rubocop-migration 0.2.0 → 0.3.2

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Avoid renaming columns that are in use.
+      #
+      # It will cause errors in your application.
+      # 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 column is in use.
+      #
+      # @example
+      #   # bad
+      #   class RenameUsersSettingsToProperties < ActiveRecord::Migration[7.0]
+      #     def change
+      #       rename_column :users, :settings, :properties
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddUsersProperties < ActiveRecord::Migration[7.0]
+      #     def change
+      #       add_column :users, :properties, :jsonb
+      #     end
+      #   end
+      #
+      #   class User < ApplicationRecord
+      #     self.ignored_columns += %w[settings]
+      #   end
+      #
+      #   class RemoveUsersSettings < ActiveRecord::Migration[7.0]
+      #     def change
+      #       remove_column :users, :settings
+      #     end
+      #   end
+      class RenameColumn < RuboCop::Cop::Base
+        MSG = 'Avoid renaming columns that are in use.'
+
+        RESTRICT_ON_SEND = %i[
+          rename_column
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless bad?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        # @!method rename_column?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :rename_column?, <<~PATTERN
+          (send
+            nil?
+            :rename_column
+            ...
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          rename_column?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Avoid renaming tables that are in use.
+      #
+      # It will cause errors in your application.
+      # A safer approach is to:
+      #
+      # 1. Create a new table
+      # 2. Write to both tables
+      # 3. Backfill data from the old table to new table
+      # 4. Move reads from the old table to the new table
+      # 5. Stop writing to the old table
+      # 6. Drop the old table
+      #
+      # @safety
+      #   Only meaningful if the table is in use.
+      #
+      # @example
+      #   # bad
+      #   class RenameUsersToAccouts < ActiveRecord::Migration[7.0]
+      #     def change
+      #       rename_table :users, :accounts
+      #     end
+      #   end
+      #
+      #   # good
+      #   class AddAccounts < ActiveRecord::Migration[7.0]
+      #     def change
+      #       create_table :accounts do |t|
+      #         t.string :name, null: false
+      #       end
+      #     end
+      #   end
+      #
+      #   class RemoveUsers < ActiveRecord::Migration[7.0]
+      #     def change
+      #       remove_table :users
+      #     end
+      #   end
+      class RenameTable < RuboCop::Cop::Base
+        MSG = 'Avoid renaming tables that are in use.'
+
+        RESTRICT_ON_SEND = %i[
+          rename_table
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          return unless bad?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        # @!method rename_table?(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [Boolean]
+        def_node_matcher :rename_table?, <<~PATTERN
+          (send
+            nil?
+            :rename_table
+            ...
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def bad?(node)
+          rename_table?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Migration
+      # Avoid using MySQL reserved words as identifiers.
+      #
+      # @example
+      #   # bad
+      #   # NOTE: `role` is a reserved word in MySQL.
+      #   add_column :users, :role, :string
+      #
+      #   # good
+      #   add_column :users, :some_other_good_name, :string
+      class ReservedWordMysql < RuboCop::Cop::Base
+        include ::RuboCop::Migration::CopConcerns::ColumnTypeMethod
+
+        MSG = 'Avoid using MySQL reserved words as identifiers.'
+
+        # Obtained from https://dev.mysql.com/doc/refman/8.0/en/keywords.html.
+        PATH_TO_RESERVED_WORDS_FILE = File.expand_path(
+          '../../../../data/reserved_words_mysql.txt',
+          __dir__
+        ).freeze
+
+        RESTRICT_ON_SEND = [
+          :add_column,
+          :add_index,
+          :add_reference,
+          :create_join_table,
+          :create_table,
+          :rename,
+          :rename_column,
+          :rename_index,
+          :rename_table,
+          *COLUMN_TYPE_METHOD_NAMES
+        ].freeze
+
+        class << self
+          # @return [Array<String>]
+          def reserved_words
+            @reserved_words ||= ::Set.new(
+              ::File.read(PATH_TO_RESERVED_WORDS_FILE).split("\n")
+            ).freeze
+          end
+        end
+
+        # @param node [RuboCop::AST::DefNode]
+        # @return [void]
+        def on_send(node)
+          offended_identifier_nodes_from(node).each do |identifier_node|
+            add_offense(identifier_node)
+          end
+        end
+
+        private
+
+        # @!method index_name_option_from_add_index(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :index_name_option_from_add_index, <<~PATTERN
+          (send
+            nil?
+            :add_index
+            _
+            _
+            (hash
+              <
+                (pair
+                  (sym :name)
+                  $_
+                )
+              >
+              ...
+            )
+          )
+        PATTERN
+
+        # @!method index_name_option_from_add_reference(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :index_name_option_from_add_reference, <<~PATTERN
+          (send
+            nil?
+            :add_reference
+            _
+            _
+            (hash
+              <
+                (pair
+                  (sym :index)
+                  (hash
+                    <
+                      (pair
+                        (sym :name)
+                        $_
+                      )
+                    >
+                    ...
+                  )
+                )
+              >
+              ...
+            )
+          )
+        PATTERN
+
+        # @!method index_name_option_from_column_type(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :index_name_option_from_column_type, <<~PATTERN
+          (send
+            lvar
+            COLUMN_TYPE_METHOD_NAMES
+            _
+            (hash
+              <
+                (pair
+                  (sym :index)
+                  (hash
+                    <
+                      (pair
+                        (sym :name)
+                        $_
+                      )
+                      ...
+                    >
+                  )
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @!method table_name_option_from(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :table_name_option_from, <<~PATTERN
+          (send
+            nil?
+            :create_join_table
+            _
+            _
+            (hash
+              <
+                (pair
+                  (sym :table_name)
+                  $_
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Array<RuboCop::AST::Node>]
+        def identifier_column_name_nodes_from(node)
+          case node.method_name
+          when :add_column, :rename
+            [node.arguments[1]]
+          when :rename_column
+            [node.arguments[2]]
+          when *COLUMN_TYPE_METHOD_NAMES
+            [node.arguments[0]]
+          else
+            []
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Array<RuboCop::AST::Node>]
+        def identifier_index_name_nodes_from(node)
+          case node.method_name
+          when :add_index
+            [index_name_option_from_add_index(node)].compact
+          when :add_reference
+            [index_name_option_from_add_reference(node)].compact
+          when :rename_index
+            [node.arguments[2]]
+          when *COLUMN_TYPE_METHOD_NAMES
+            [index_name_option_from_column_type(node)].compact
+          else
+            []
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Array<RuboCop::AST::Node>]
+        def identifier_nodes_from(node)
+          identifier_table_name_nodes_from(node) +
+            identifier_column_name_nodes_from(node) +
+            identifier_index_name_nodes_from(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Array<RuboCop::AST::Node>]
+        def identifier_table_name_nodes_from(node)
+          case node.method_name
+          when :create_join_table
+            [table_name_option_from(node)].compact
+          when :create_table
+            [node.arguments[0]]
+          when :rename_table
+            [node.arguments[1]]
+          else
+            []
+          end
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<RuboCop::AST::Node>]
+        def offended_identifier_nodes_from(node)
+          identifier_nodes_from(node).select do |identifier_node|
+            reserved_word_identifier_node?(identifier_node)
+          end
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Boolean]
+        def reserved_word_identifier_node?(node)
+          return false unless node.respond_to?(:value)
+
+          self.class.reserved_words.include?(node.value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/migration/config_loader.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Migration
+    # Merge default RuboCop config with plugin config.
+    class ConfigLoader
+      class << self
+        # @param path [String]
+        # @return [RuboCop::Config]
+        def call(path:)
+          new(path: path).call
+        end
+      end
+
+      # @param path [String]
+      def initialize(path:)
+        @path = path
+      end
+
+      # @return [RuboCop::Config]
+      def call
+        ::RuboCop::ConfigLoader.merge_with_default(
+          plugin_config,
+          @path
+        )
+      end
+
+      private
+
+      # @return [RuboCop::Config]
+      def plugin_config
+        config = ::RuboCop::Config.new(
+          plugin_config_hash,
+          @path
+        )
+        config.make_excludes_absolute
+        config
+      end
+
+      # @return [Hash]
+      def plugin_config_hash
+        ::RuboCop::ConfigLoader.send(
+          :load_yaml_configuration,
+          @path
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/migration/cop_concerns/batch_processing.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Migration
+    module CopConcerns
+      module BatchProcessing
+        BATCH_PROCESSING_METHOD_NAMES = ::Set.new(
+          %i[
+            delete_all
+            update_all
+          ]
+        ).freeze
+
+        class << self
+          def included(klass)
+            super
+            klass.class_eval do
+              # @!method batch_processing?(node)
+              #   @param node [RuboCop::AST::SendNode]
+              #   @return [Boolean]
+              def_node_matcher :batch_processing?, <<~PATTERN
+                (send
+                  !nil?
+                  BATCH_PROCESSING_METHOD_NAMES
+                  ...
+                )
+              PATTERN
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/migration/cop_concerns/column_type_method.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Migration
+    module CopConcerns
+      module ColumnTypeMethod
+        COLUMN_TYPE_METHOD_NAMES = ::Set.new(
+          %i[
+            bigint
+            binary
+            blob
+            boolean
+            date
+            datetime
+            decimal
+            float
+            integer
+            numeric
+            primary_key
+            string
+            text
+            time
+          ]
+        ).freeze
+      end
+    end
+  end
+end

data/lib/rubocop/migration/cop_concerns/disable_ddl_transaction.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Migration
+    module CopConcerns
+      module DisableDdlTransaction
+        class << self
+          def included(klass)
+            super
+            klass.class_eval do
+              # @!method disable_ddl_transaction?(node)
+              #   @param node [RuboCop::AST::SendNode]
+              #   @return [Boolean]
+              def_node_matcher :disable_ddl_transaction?, <<~PATTERN
+                (send
+                  nil?
+                  :disable_ddl_transaction!
+                  ...
+                )
+              PATTERN
+            end
+          end
+        end
+
+        private
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def insert_disable_ddl_transaction(
+          corrector,
+          node
+        )
+          corrector.insert_before(
+            node.each_ancestor(:def).first,
+            "disable_ddl_transaction!\n\n  "
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def within_disable_ddl_transaction?(node)
+          node.each_ancestor(:def).first&.left_siblings&.any? do |sibling|
+            sibling.is_a?(::RuboCop::AST::SendNode) &&
+              disable_ddl_transaction?(sibling)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/migration/cop_concerns.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Migration
+    module CopConcerns
+      autoload :BatchProcessing, 'rubocop/migration/cop_concerns/batch_processing'
+      autoload :ColumnTypeMethod, 'rubocop/migration/cop_concerns/column_type_method'
+      autoload :DisableDdlTransaction, 'rubocop/migration/cop_concerns/disable_ddl_transaction'
+    end
+  end
+end

data/lib/rubocop/migration/rubocop_extension.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'config_loader'
+
+RuboCop::ConfigLoader.instance_variable_set(
+  :@default_configuration,
+  RuboCop::Migration::ConfigLoader.call(
+    path: ::File.expand_path(
+      '../../../config/default.yml',
+      __dir__
+    )
+  )
+)

data/lib/rubocop/migration/version.rb

@@ -1,5 +1,7 @@
-module RuboCop
+# frozen_string_literal: true
+
+module Rubocop
   module Migration
-    VERSION = "0.2.0"
+    VERSION = '0.3.2'
   end
 end

data/lib/rubocop/migration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'migration/cop_concerns'
+require_relative 'migration/rubocop_extension'
+require_relative 'migration/version'
+
+require_relative 'cop/migration/add_check_constraint'
+require_relative 'cop/migration/add_column_with_default_value'
+require_relative 'cop/migration/add_foreign_key'
+require_relative 'cop/migration/add_index_columns_count'
+require_relative 'cop/migration/add_index_concurrently'
+require_relative 'cop/migration/add_index_duplicate'
+require_relative 'cop/migration/batch_in_batches'
+require_relative 'cop/migration/batch_in_transaction'
+require_relative 'cop/migration/batch_with_throttling'
+require_relative 'cop/migration/change_column'
+require_relative 'cop/migration/change_column_null'
+require_relative 'cop/migration/create_table_force'
+require_relative 'cop/migration/jsonb'
+require_relative 'cop/migration/remove_column'
+require_relative 'cop/migration/rename_column'
+require_relative 'cop/migration/rename_table'
+require_relative 'cop/migration/reserved_word_mysql'

data/rubocop-migration.gemspec

@@ -1,38 +1,32 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "rubocop/migration/version"
+# frozen_string_literal: true
 
-Gem::Specification.new do |spec|
-  spec.name          = "rubocop-migration"
-  spec.version       = RuboCop::Migration::VERSION
-  spec.authors       = ["Peter Graham"]
-  spec.email         = ["peter@wealthsimple.com"]
+require_relative 'lib/rubocop/migration/version'
 
-  spec.summary       = %q{RuboCop extension for ActiveRecord migrations.}
-  spec.description   = %q{RuboCop extension to catch common pitfalls in ActiveRecord migrations.}
-  spec.homepage      = "https://github.com/wealthsimple/rubocop-migration"
+Gem::Specification.new do |spec|
+  spec.name = 'rubocop-migration'
+  spec.version = Rubocop::Migration::VERSION
+  spec.authors = ['Ryo Nakamura']
+  spec.email = ['r7kamura@gmail.com']
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  spec.license       = "MIT"
+  spec.summary = 'RuboCop extension focused on ActiveRecord migration.'
+  spec.homepage = 'https://github.com/r7kamura/rubocop-migration'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.7'
 
-  spec.required_ruby_version = ">= 2.3.0"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/releases"
 
-  spec.add_dependency "activesupport", ">= 4"
-  spec.add_dependency "activerecord", ">= 4"
-  spec.add_dependency "strong_migrations", "~> 0.1"
-  spec.add_dependency "rubocop", ">= 0.48.0"
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rspec-its"
-  spec.add_development_dependency "rspec-collection_matchers"
-  spec.add_development_dependency "rspec_junit_formatter", "~> 0.2"
-  spec.add_development_dependency "pry"
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'rubocop', '>= 1.34'
+  spec.add_dependency 'rubocop-rails'
 end