active_record_doctor 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bae986a04fe63835ce7e190f32471cc06a370972161c487cac195ef33f73269
-  data.tar.gz: c5a2f92f0b31ec1faedfd65fc5abe9ef656f75b9fa933719e57f180b4fb0f28d
+  metadata.gz: 7c93e45a93d9c11392978f37626379bd322e4827aac59ca6f51400e33a009813
+  data.tar.gz: e3e920647f6b68fdec23d7e23e7e4ff3653cb8823673e56b0916d1247cbb3864
 SHA512:
-  metadata.gz: 7759e1effdfcea2382966f8973c2c132bda909b847a14914fb7a46b795a7d0407f9605efa39dfece9d889ee65b35f334f78e6664928fbbe03e349f792845ae7f
-  data.tar.gz: c563de0bbf91966325eddd2bafedb3dadcc07ca39e7c27a529fdb544113eadba4f2373e9d618a074205a8716687f7684f232a212711fcf5d50fc1484999b1074
+  metadata.gz: 54c002741991dc91c4afd46de5472d64be0ba02457d23df39bd16297a12f4192023679d281d9bc353a5de5a0c357ea960666967d820316fe5fdaceee36f99d6d
+  data.tar.gz: bb17cb57cc708b9d7e751bb79e341aac2df4de4adc5f59d2cf254ef564c0a481b8e8872f1eac34a37246eda9145a78abbb41511150bc064932504645e36453fd

data/README.md

@@ -17,6 +17,7 @@ can detect:
 * mismatched foreign key types - [`active_record_doctor:mismatched_foreign_key_type`](#detecting-mismatched-foreign-key-types)
 * tables without primary keys - [`active_record_doctor:table_without_primary_key`](#detecting-tables-without-primary-keys)
 * tables without timestamps - [`active_record_doctor:table_without_timestamps`](#detecting-tables-without-timestamps)
+* unused tables - [`active_record_doctor:unused_tables](#detecting-unused-tables)
 
 It can also:
 
@@ -302,16 +303,15 @@ Supported configuration options:
 
 ### Detecting Missing Foreign Key Constraints
 
-If `users.profile_id` references a row in `profiles` then this can be expressed
-at the database level with a foreign key constraint. It _forces_
-`users.profile_id` to point to an existing row in `profiles`. The problem is
-that in many legacy Rails apps, the constraint isn't enforced at the database
-level.
+If `User` defines a `belongs_to` association to `Profile` then the underlying
+column (`users.profile_id` by convention) should be marked as a foreign key in
+the database. If it's not then it's possible to end up in a situation where a
+user is referencing a non-existent profile.
 
 `active_record_doctor` can automatically detect foreign keys that could benefit
 from a foreign key constraint (a future version will generate a migration that
-add the constraint; for now, it's your job). You can obtain the list of foreign
-keys with the following command:
+add the constraint; for now, it's your job). You can obtain the list of missing
+foreign key constraints with the following command:
 
 ```bash
 bundle exec rake active_record_doctor:missing_foreign_keys
@@ -331,9 +331,9 @@ end
 Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
-- `ignore_tables` - tables whose columns should not be checked.
-- `ignore_columns` - columns, written as table.column, that should not be
-  checked.
+- `ignore_models` - models whose associations should not be checked.
+- `ignore_associations` - associations, written as Model.association, that
+  should not be checked.
 
 ### Detecting Models Referencing Undefined Tables
 
@@ -666,15 +666,35 @@ Supported configuration options:
 - `enabled` - set to `false` to disable the detector altogether
 - `ignore_tables` - tables whose timestamp columns existence should not be checked
 
-## Ruby and Rails Compatibility Policy
+### Detecting Unused Tables
 
-The goal of the policy is to ensure proper functioning in reasonable
-combinations of Ruby and Rails versions. Specifically:
+**WARNING**: this detector is disabled by default and has to be turned on explicitly.
+
+When a table is not used by the application it should usually be dropped from the database.
+
+Running the command below will list all tables that are not referenced by any model:
+
+```
+bundle exec rake active_record_doctor:unused_tables
+```
+
+The output of the command looks like this:
+
+```
+The users table is not referenced by any Rails model and can be dropped
+```
+
+Supported configuration options:
+
+- `enabled` - set to `true` to enable the detector
+- `ignore_tables` - tables that are not represented by models but cannot yet be dropped from the database (i.e. because the deployed version of the code may still be reading it)
+
+## Ruby and Rails Compatibility Policy
 
-1. If a Rails version is officially supported by the Rails Core Team then it's
+1. `active_record_doctor` supports all Ruby on Rails versions that are supported
+   by the Rails core team.
+2. If a Ruby version is compatible with a supported Rails version then it's also
    supported by `active_record_doctor`.
-2. If a Ruby version is compatible with a supported Rails version then it's
-   also supported by `active_record_doctor`.
 3. Only the most recent teeny Ruby versions and patch Rails versions are supported.
 
 ## Author

data/lib/active_record_doctor/config/default.rb

@@ -36,8 +36,8 @@ ActiveRecordDoctor.configure do
 
   detector :missing_foreign_keys,
     enabled: true,
-    ignore_tables: [],
-    ignore_columns: []
+    ignore_models: [],
+    ignore_associations: []
 
   detector :missing_non_null_constraint,
     enabled: true,
@@ -83,4 +83,8 @@ ActiveRecordDoctor.configure do
     enabled: true,
     ignore_tables: [],
     ignore_columns: []
+
+  detector :unused_tables,
+    enabled: false,
+    ignore_tables: []
 end

data/lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -18,9 +18,12 @@ module ActiveRecordDoctor
 
       private
 
-      def message(model:, attribute:, table:, database_maximum:, model_maximum:)
+      def message(model:, column:, table:, database_maximum:, model_maximum:)
+        attribute = column.name
         # rubocop:disable Layout/LineLength
-        if database_maximum && model_maximum
+        if database_maximum && column.respond_to?(:array?) && column.array?
+          "the schema limits each #{table}.#{attribute} array element to #{database_maximum} characters - use a custom validation for this attribute or add it to the ignore list"
+        elsif database_maximum && model_maximum
           "the schema limits #{table}.#{attribute} to #{database_maximum} characters but the length validator on #{model}.#{attribute} enforces a maximum of #{model_maximum} characters - set both limits to the same value or remove both"
         elsif database_maximum && model_maximum.nil?
           "the schema limits #{table}.#{attribute} to #{database_maximum} characters but there's no length validator on #{model}.#{attribute} - remove the database limit or add the validator"
@@ -40,7 +43,7 @@ module ActiveRecordDoctor
 
             problem!(
               model: model.name,
-              attribute: column.name,
+              column: column,
               table: model.table_name,
               database_maximum: database_maximum,
               model_maximum: model_maximum

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -7,12 +7,12 @@ module ActiveRecordDoctor
     class MissingForeignKeys < Base # :nodoc:
       @description = "detect foreign-key-like columns lacking an actual foreign key constraint"
       @config = {
-        ignore_tables: {
-          description: "tables whose columns should not be checked",
+        ignore_models: {
+          description: "models whose columns should not be checked",
           global: true
         },
-        ignore_columns: {
-          description: "columns, written as table.column, that should not be checked"
+        ignore_associations: {
+          description: "associations, written as Model.association, that should not be checked"
         }
       }
 
@@ -23,42 +23,18 @@ module ActiveRecordDoctor
       end
 
       def detect
-        each_table(except: config(:ignore_tables)) do |table|
-          each_column(table, except: config(:ignore_columns)) do |column|
-            # We need to skip polymorphic associations as they can reference
-            # multiple tables but a foreign key constraint can reference
-            # a single predefined table.
-            next unless looks_like_foreign_key?(column)
-            next if foreign_key?(table, column)
-            next if polymorphic_foreign_key?(table, column)
-            next if model_destroyed_async?(table, column)
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          foreign_keys = connection.foreign_keys(model.table_name)
+          foreign_key_columns = foreign_keys.map { |key| key.options[:column] }
 
-            problem!(table: table, column: column.name)
-          end
-        end
-      end
-
-      def foreign_key?(table, column)
-        connection.foreign_keys(table).any? do |foreign_key|
-          foreign_key.options[:column] == column.name
-        end
-      end
+          each_association(model, type: :belongs_to) do |association|
+            next if ignored?("#{model.name}.#{association.name}", config(:ignore_associations))
+            next if association.options[:polymorphic]
 
-      def polymorphic_foreign_key?(table, column)
-        type_column_name = column.name.sub(/_id\Z/, "_type")
-        connection.columns(table).any? do |another_column|
-          another_column.name == type_column_name
-        end
-      end
+            has_foreign_key = foreign_key_columns.include?(association.foreign_key)
+            next if has_foreign_key
 
-      def model_destroyed_async?(table, column)
-        # Check if there are any models having `has_many ..., dependent: :destroy_async`
-        # referencing the specified table.
-        models.any? do |model|
-          model.reflect_on_all_associations(:has_many).any? do |reflection|
-            reflection.options[:dependent] == :destroy_async &&
-              reflection.foreign_key == column.name &&
-              reflection.klass.table_name == table
+            problem!(table: model.table_name, column: association.foreign_key)
           end
         end
       end

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -21,14 +21,14 @@ module ActiveRecordDoctor
 
       private
 
-      def message(type:, column_or_association:, model:)
+      def message(type:, column:, reflection:, model:)
         case type
         when :missing_validator
-          "add a `presence` validator to #{model}.#{column_or_association} - it's NOT NULL but lacks a validator"
+          "add a `presence` validator to #{model}.#{column} - it's NOT NULL but lacks a validator"
         when :optional_association
-          "add `optional: false` to #{model}.#{column_or_association} - the foreign key #{column_or_association}_id is NOT NULL" # rubocop:disable Layout/LineLength
+          "add `optional: false` to #{model}.#{reflection.name} - the foreign key #{reflection.foreign_key} is NOT NULL"
         when :optional_polymorphic_association
-          "add `optional: false` to #{model}.#{column_or_association} - the foreign key #{column_or_association}_id or type #{column_or_association}_type are NOT NULL" # rubocop:disable Layout/LineLength
+          "add `optional: false` to #{model}.#{reflection.name} - the foreign key #{reflection.foreign_key} or type #{reflection.foreign_type} are NOT NULL" # rubocop:disable Layout/LineLength
         end
       end
 
@@ -56,7 +56,7 @@ module ActiveRecordDoctor
               (config(:ignore_columns_with_default) && (column.default || column.default_function)) ||
 
               # Explicitly ignored columns should be skipped.
-              config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+              ignored?("#{model.name}.#{column.name}", config(:ignore_attributes))
           end
 
           # At this point the only columns that are left are those that DO
@@ -76,29 +76,31 @@ module ActiveRecordDoctor
           # that are validated directly or via an association name.
           model.validators.each do |validator|
             problematic_columns.reject! do |column|
-              # Translate a foreign key or type to the association name.
-              attribute = column_name_to_association_name[column.name] || column.name.to_sym
+              attribute_names = [
+                column.name.to_sym,
+                column_name_to_association_name[column.name]
+              ].compact
 
               case validator
 
               # A regular presence validator is enough if the column name is
               # listed among the attributes it's validating.
               when ActiveRecord::Validations::PresenceValidator
-                validator.attributes.include?(attribute)
+                (validator.attributes & attribute_names).present?
 
               # An inclusion validator ensures the column is not nil if it covers
               # the column and nil is NOT one of the values it allows.
               when ActiveModel::Validations::InclusionValidator
                 validator_items = inclusion_or_exclusion_validator_items(validator)
-                validator.attributes.include?(attribute) &&
-                  (validator_items.is_a?(Proc) || validator_items.exclude?(nil))
+                (validator.attributes & attribute_names).present? &&
+                  (dynamic_validator_items?(validator_items) || validator_items.exclude?(nil))
 
               # An exclusion validator ensures the column is not nil if it covers
               # the column and excludes nil as an allowed value explicitly.
               when ActiveModel::Validations::ExclusionValidator
                 validator_items = inclusion_or_exclusion_validator_items(validator)
-                validator.attributes.include?(attribute) &&
-                  (validator_items.is_a?(Proc) || validator_items.include?(nil))
+                (validator.attributes & attribute_names).present? &&
+                  (dynamic_validator_items?(validator_items) || validator_items.include?(nil))
 
               end
             end
@@ -109,7 +111,7 @@ module ActiveRecordDoctor
           problematic_associations = []
           problematic_polymorphic_associations = []
 
-          model.reflect_on_all_associations.each do |reflection|
+          model.reflect_on_all_associations(:belongs_to).each do |reflection|
             foreign_key_column = problematic_columns.find { |column| column.name == reflection.foreign_key }
             if reflection.polymorphic?
               # If the foreign key and type are not one of the columns that lack
@@ -125,7 +127,7 @@ module ActiveRecordDoctor
 
               # ... report an error about an incorrectly configured polymorphic
               # association.
-              problematic_polymorphic_associations << reflection.name
+              problematic_polymorphic_associations << reflection
             else
               # If the foreign key is not one of the columns that lack a
               # validator then it means the association added a validator and is
@@ -137,7 +139,7 @@ module ActiveRecordDoctor
               problematic_columns.delete(foreign_key_column)
 
               # ... report an error about an incorrectly configured association.
-              problematic_associations << reflection.name
+              problematic_associations << reflection
             end
           end
 
@@ -145,22 +147,22 @@ module ActiveRecordDoctor
           # ignored should be removed from the output. It's NOT enough to skip
           # processing them in the loop above because their underlying foreign
           # key and type columns must be removed from output, too.
-          problematic_associations.reject! do |name|
-            config(:ignore_attributes).include?("#{model.name}.#{name}")
+          problematic_associations.reject! do |reflection|
+            config(:ignore_attributes).include?("#{model.name}.#{reflection.name}")
           end
-          problematic_polymorphic_associations.reject! do |name|
-            config(:ignore_attributes).include?("#{model.name}.#{name}")
+          problematic_polymorphic_associations.reject! do |reflection|
+            config(:ignore_attributes).include?("#{model.name}.#{reflection.name}")
           end
 
           # Job is done and all accumulated errors can be reported.
-          problematic_polymorphic_associations.each do |name|
-            problem!(type: :optional_polymorphic_association, column_or_association: name, model: model.name)
+          problematic_polymorphic_associations.each do |reflection|
+            problem!(type: :optional_polymorphic_association, column: nil, reflection: reflection, model: model.name)
           end
-          problematic_associations.each do |name|
-            problem!(type: :optional_association, column_or_association: name, model: model.name)
+          problematic_associations.each do |reflection|
+            problem!(type: :optional_association, column: nil, reflection: reflection, model: model.name)
           end
           problematic_columns.each do |column|
-            problem!(type: :missing_validator, column_or_association: column.name, model: model.name)
+            problem!(type: :missing_validator, column: column.name, reflection: nil, model: model.name)
           end
         end
       end
@@ -170,6 +172,12 @@ module ActiveRecordDoctor
         validator.options[:in] || validator.options[:within] || []
       end
 
+      # The allowed values can be a Proc or a method name (Symbol) that's resolved
+      # at validation time, so the set of values isn't known statically.
+      def dynamic_validator_items?(validator_items)
+        validator_items.is_a?(Proc) || validator_items.is_a?(Symbol)
+      end
+
       # Determines whether the given column is used as a counter cache column by
       # a has_many association on the model.
       def counter_cache_column?(model, column)

data/lib/active_record_doctor/detectors/unused_tables.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class UnusedTables < Base # :nodoc:
+      @description = "detect tables not referenced by any model"
+      @config = {
+        ignore_tables: {
+          description: "tables whose corresponding models should not be checked for existence",
+          global: true
+        }
+      }
+
+      private
+
+      def message(table:)
+        "The #{table} table is not referenced by any Rails model and can be dropped"
+      end
+
+      def detect
+        each_table(except: config(:ignore_tables)) do |table|
+          next if models.any? { |model| model.table_name == table }
+
+          problem!(table: table)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordDoctor
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/lib/active_record_doctor.rb

@@ -22,6 +22,7 @@ require "active_record_doctor/detectors/short_primary_key_type"
 require "active_record_doctor/detectors/mismatched_foreign_key_type"
 require "active_record_doctor/detectors/table_without_primary_key"
 require "active_record_doctor/detectors/table_without_timestamps"
+require "active_record_doctor/detectors/unused_tables"
 require "active_record_doctor/errors"
 require "active_record_doctor/help"
 require "active_record_doctor/runner"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_doctor
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Greg Navis
@@ -23,20 +23,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: minitest-fork_executor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest-mock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.27'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.27'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -111,16 +139,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: transient_record
   requirement: !ruby/object:Gem::Requirement
@@ -144,9 +172,6 @@ files:
 - MIT-LICENSE.txt
 - README.md
 - lib/active_record_doctor.rb
-- lib/active_record_doctor/adapters/database.rb
-- lib/active_record_doctor/adapters/table.rb
-- lib/active_record_doctor/adapters/validators.rb
 - lib/active_record_doctor/config.rb
 - lib/active_record_doctor/config/default.rb
 - lib/active_record_doctor/config/loader.rb
@@ -167,6 +192,7 @@ files:
 - lib/active_record_doctor/detectors/undefined_table_references.rb
 - lib/active_record_doctor/detectors/unindexed_deleted_at.rb
 - lib/active_record_doctor/detectors/unindexed_foreign_keys.rb
+- lib/active_record_doctor/detectors/unused_tables.rb
 - lib/active_record_doctor/errors.rb
 - lib/active_record_doctor/help.rb
 - lib/active_record_doctor/logger.rb
@@ -200,7 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Identify database issues before they hit production.
 test_files: []

data/lib/active_record_doctor/adapters/database.rb

@@ -1,17 +0,0 @@
-module ActiveRecordDoctor
-  module Adapters
-    class Database
-      def initialize(connection)
-        @connection = connection
-      end
-
-      def tables
-        connection.tables
-      end
-
-      private
-
-      attr_reader :connection
-    end
-  end
-end

data/lib/active_record_doctor/adapters/table.rb

@@ -1,18 +0,0 @@
-module ActiveRecordDoctor
-  module Adapters
-    class Table
-      def initialize(connection, table_name)
-        @connection = connection
-        @table_name = table_name
-      end
-
-      def columns
-        connection.columns(table_name)
-      end
-
-      private
-
-      attr_reader :connection, :table_name
-    end
-  end
-end

data/lib/active_record_doctor/adapters/validators.rb

@@ -1,16 +0,0 @@
-module ActiveRecordDoctor
-  module Adapters
-    class Validators
-      def initialize(model_class, kind: :any)
-        @model_class = model_class
-      end
-
-      def each
-      end
-
-      private
-
-      attr_reader :model_class
-    end
-  end
-end