sevencop 0.21.0 → 0.22.0

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

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # 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 RailsMigrationRemoveColumn < 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
+
+        # @return [#parse]
+        def parser
+          parser_class.new(::RuboCop::AST::Builder.new)
+        end
+
+        # @return [Class]
+        def parser_class
+          ::Parser.const_get(
+            "Ruby#{target_ruby_version.to_s.delete('.')}"
+          )
+        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/sevencop/rails_migration_rename_column.rb

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

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

@@ -15,24 +15,7 @@ module RuboCop
       #   # good
       #   add_column :users, :some_other_good_name, :string
       class RailsMigrationReservedWordMysql < RuboCop::Cop::Base
-        COLUMN_TYPE_METHOD_NAMES = ::Set.new(
-          %i[
-            bigint
-            binary
-            blob
-            boolean
-            date
-            datetime
-            decimal
-            float
-            integer
-            numeric
-            primary_key
-            string
-            text
-            time
-          ]
-        ).freeze
+        include ::Sevencop::CopConcerns::ColumnTypeMethod
 
         MSG = 'Avoid using MySQL reserved words as identifiers.'
 
@@ -129,7 +112,7 @@ module RuboCop
         #   @return [RuboCop::AST::Node, nil]
         def_node_matcher :index_name_option_from_column_type, <<~PATTERN
           (send
-            (lvar _)
+            lvar
             COLUMN_TYPE_METHOD_NAMES
             _
             (hash

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # Keep unique index columns count less than a specified number.
+      #
+      # Adding a non-unique index with more than three columns rarely improves performance.
+      # Instead, start an index with columns that narrow down the results the most.
+      #
+      # @example
+      #   # bad
+      #   add_index :users, %i[a b c d]
+      #
+      #   # good (`MaxColumnsCount: 3` by default)
+      #   add_index :users, %i[a b c]
+      class RailsMigrationUniqueIndexColumnsCount < RuboCop::Cop::Base
+        RESTRICT_ON_SEND = %i[
+          add_index
+          index
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          column_names_node = column_names_node_from(node)
+          return unless column_names_node
+
+          column_names_count = columns_count_from(column_names_node)
+          return if column_names_count <= max_columns_count
+
+          add_offense(
+            column_names_node,
+            message: "Keep unique index columns count less than #{max_columns_count}."
+          )
+        end
+
+        private
+
+        # @!method column_names_node_from_add_index(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :column_names_node_from_add_index, <<~PATTERN
+          (send
+            nil?
+            _
+            _
+            $({array | sym} ...)
+          )
+        PATTERN
+
+        # @!method column_names_node_from_index(node)
+        #   @param node [RuboCop::AST::SendNode]
+        #   @return [RuboCop::AST::Node, nil]
+        def_node_matcher :column_names_node_from_index, <<~PATTERN
+          (send
+            (lvar ...)
+            _
+            $({array | sym} ...)
+          )
+        PATTERN
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node, nil]
+        def column_names_node_from(node)
+          case node.method_name
+          when :add_index
+            column_names_node_from_add_index(node)
+          when :index
+            column_names_node_from_index(node)
+          end
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Integer, nil]
+        def columns_count_from(node)
+          case node.type
+          when :array
+            node.values.count
+          when :sym
+            1
+          end
+        end
+
+        # @return [Integer]
+        def max_columns_count
+          cop_config['MaxColumnsCount']
+        end
+      end
+    end
+  end
+end

data/lib/sevencop/config_loader.rb

@@ -5,23 +5,24 @@ require 'rubocop'
 module Sevencop
   # Merge default RuboCop config with plugin config.
   class ConfigLoader
-    PLUGIN_CONFIG_PATH = ::File.expand_path(
-      '../../config/default.yml',
-      __dir__
-    )
-
     class << self
+      # @param path [String]
       # @return [RuboCop::Config]
-      def call
-        new.call
+      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,
-        PLUGIN_CONFIG_PATH
+        @path
       )
     end
 
@@ -31,7 +32,7 @@ module Sevencop
     def plugin_config
       config = ::RuboCop::Config.new(
         plugin_config_hash,
-        PLUGIN_CONFIG_PATH
+        @path
       )
       config.make_excludes_absolute
       config
@@ -41,7 +42,7 @@ module Sevencop
     def plugin_config_hash
       ::RuboCop::ConfigLoader.send(
         :load_yaml_configuration,
-        PLUGIN_CONFIG_PATH
+        @path
       )
     end
   end

data/lib/sevencop/cop_concerns/batch_processing.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sevencop
+  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

data/lib/sevencop/cop_concerns/column_type_method.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sevencop
+  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

data/lib/sevencop/cop_concerns/disable_ddl_transaction.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Sevencop
+  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