active_record_doctor 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bae986a04fe63835ce7e190f32471cc06a370972161c487cac195ef33f73269
-  data.tar.gz: c5a2f92f0b31ec1faedfd65fc5abe9ef656f75b9fa933719e57f180b4fb0f28d
+  metadata.gz: 94e700a1c78ee5e9657d1107578c2932a84acba7f592ab6a416e5c063520a311
+  data.tar.gz: 8496adb8a597250ec95276fc9fbad50397667f7de2336f80405203b3a3c2a459
 SHA512:
-  metadata.gz: 7759e1effdfcea2382966f8973c2c132bda909b847a14914fb7a46b795a7d0407f9605efa39dfece9d889ee65b35f334f78e6664928fbbe03e349f792845ae7f
-  data.tar.gz: c563de0bbf91966325eddd2bafedb3dadcc07ca39e7c27a529fdb544113eadba4f2373e9d618a074205a8716687f7684f232a212711fcf5d50fc1484999b1074
+  metadata.gz: 79803ef2db49147fdf2daf5983a3f36fb895704d150347442bebdc192a6980ecb8cd438c23fe335941284e0a39aee8c3e1a725bfe3845c7a0d3dde03830068dc
+  data.tar.gz: 2feb5b594c369dc3d39e0f85540724474e5caa7573e0d0f18a5dcddd63d12113ec4c670ef374b475f237bd3d75fe7281bca0b0d219aac6582cbddbe59bdc2340

data/README.md

@@ -302,16 +302,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 +330,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
 

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,

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,28 +76,30 @@ 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.attributes & attribute_names).present? &&
                   (validator_items.is_a?(Proc) || 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.attributes & attribute_names).present? &&
                   (validator_items.is_a?(Proc) || validator_items.include?(nil))
 
               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

data/lib/active_record_doctor/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_doctor
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Greg Navis
@@ -144,9 +144,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

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