rubocop-migration 0.2.0 → 0.4.0

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

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