active_record_doctor 1.10.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1bf7642b1c7b471fbf78956825067ff070d261d4c47a182d1aaf00f10b98b7
-  data.tar.gz: 6e6fc746327d6db30c282d7964ae778b254107281d9626a251f8593d6ce85db4
+  metadata.gz: fef82b1493488683e11bc72273e142479cb47234651a8aa772a83121960f9309
+  data.tar.gz: c99afc25d8307ff0814e0459790f3d7fcf0b015d9f37f118870a9a1cfa2cf460
 SHA512:
-  metadata.gz: a0a2d71947728b9d6a130901d94d1ed8c2ede9dde209e91897a8beb8b757da2fea854b89a3a3f6223d658c203e75e687edbee2af37b2203ddb24b28e831439e8
-  data.tar.gz: f0fe87dd6acf379ef946bc513504342c3977bf5c4d7f71eca79290c693b318f0a838c31b95111f68635579cdfa26249d5a95fd456817b6a3c32023c1b4fe0fd1
+  metadata.gz: ab75ff192c31cfc10cbd5c4106ca0033cc4d408c1e4977a417f76c53f2a2e73e37e5706162cd4807c700808e171756ddda022af6658b60f460d78109f9bea2ee
+  data.tar.gz: 075625a08ac5f192a68ed6c99409a4acf85cadb77ec117d6933186c2bf4d07e5aaf08928e9f30d5dd96b263e8e530a4a4da848ef5a4dfc82d5dae0df2475f7d2

data/README.md

@@ -509,7 +509,7 @@ Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
 - `ignore_models` - models whose associations should not be checked.
-- `ignore_columns` - associations, written as Model.association, that should not
+- `ignore_associations` - associations, written as Model.association, that should not
   be checked.
 
 ### Detecting Primary Keys Having Short Integer Types

data/lib/active_record_doctor/detectors/base.rb

@@ -13,8 +13,8 @@ module ActiveRecordDoctor
       class << self
         attr_reader :description
 
-        def run(config, io)
-          new(config, io).run
+        def run(*args, **kwargs, &block)
+          new(*args, **kwargs, &block).run
         end
 
         def underscored_name
@@ -38,23 +38,36 @@ module ActiveRecordDoctor
         end
       end
 
-      def initialize(config, io)
+      def initialize(config:, logger:, io:)
         @problems = []
         @config = config
+        @logger = logger
         @io = io
       end
 
       def run
-        @problems = []
+        log(underscored_name) do
+          @problems = []
 
-        detect if config(:enabled)
-        @problems.each do |problem|
-          @io.puts(message(**problem))
-        end
+          if config(:enabled)
+            detect
+          else
+            log("disabled; skipping")
+          end
+
+          @problems.each do |problem|
+            @io.puts(message(**problem))
+          end
 
-        success = @problems.empty?
-        @problems = nil
-        success
+          success = @problems.empty?
+          if success
+            log("No problems found")
+          else
+            log("Found #{@problems.count} problem(s)")
+          end
+          @problems = nil
+          success
+        end
       end
 
       private
@@ -79,7 +92,16 @@ module ActiveRecordDoctor
         raise("#message should be implemented by a subclass")
       end
 
+      def log(message, &block)
+        @logger.log(message, &block)
+      end
+
       def problem!(**attrs)
+        log("Problem found") do
+          attrs.each do |key, value|
+            log("#{key}: #{value.inspect}")
+          end
+        end
         @problems << attrs
       end
 
@@ -91,23 +113,8 @@ module ActiveRecordDoctor
         @connection ||= ActiveRecord::Base.connection
       end
 
-      def indexes(table_name, except: [])
-        connection.indexes(table_name).reject do |index|
-          except.include?(index.name)
-        end
-      end
-
-      def tables(except: [])
-        tables =
-          if ActiveRecord::VERSION::STRING >= "5.1"
-            connection.tables
-          else
-            connection.data_sources
-          end
-
-        tables.reject do |table|
-          except.include?(table)
-        end
+      def indexes(table_name)
+        connection.indexes(table_name)
       end
 
       def primary_key(table_name)
@@ -121,24 +128,6 @@ module ActiveRecordDoctor
         connection.columns(table_name).find { |column| column.name == column_name }
       end
 
-      def views
-        @views ||=
-          if connection.respond_to?(:views)
-            connection.views
-          elsif postgresql?
-            ActiveRecord::Base.connection.select_values(<<-SQL)
-              SELECT relname FROM pg_class WHERE relkind IN ('m', 'v')
-            SQL
-          elsif connection.adapter_name == "Mysql2"
-            ActiveRecord::Base.connection.select_values(<<-SQL)
-              SHOW FULL TABLES WHERE table_type = 'VIEW'
-            SQL
-          else
-            # We don't support this Rails/database combination yet.
-            []
-          end
-      end
-
       def not_null_check_constraint_exists?(table, column)
         check_constraints(table).any? do |definition|
           definition =~ /\A#{column.name} IS NOT NULL\z/i ||
@@ -167,10 +156,8 @@ module ActiveRecordDoctor
         end
       end
 
-      def models(except: [])
-        ActiveRecord::Base.descendants.reject do |model|
-          model.name.start_with?("HABTM_") || except.include?(model.name)
-        end
+      def models
+        ActiveRecord::Base.descendants
       end
 
       def underscored_name
@@ -180,6 +167,149 @@ module ActiveRecordDoctor
       def postgresql?
         ["PostgreSQL", "PostGIS"].include?(connection.adapter_name)
       end
+
+      def each_model(except: [], abstract: nil, existing_tables_only: false)
+        log("Iterating over Active Record models") do
+          models.each do |model|
+            case
+            when model.name.start_with?("HABTM_")
+              log("#{model.name} - has-belongs-to-many model; skipping")
+            when except.include?(model.name)
+              log("#{model.name} - ignored via the configuration; skipping")
+            when abstract && !model.abstract_class?
+              log("#{model.name} - non-abstract model; skipping")
+            when abstract == false && model.abstract_class?
+              log("#{model.name} - abstract model; skipping")
+            when existing_tables_only && (model.table_name.nil? || !model.table_exists?)
+              log("#{model.name} - backed by a non-existent table #{model.table_name}; skipping")
+            else
+              log(model.name) do
+                yield(model)
+              end
+            end
+          end
+        end
+      end
+
+      def each_index(table_name, except: [], multicolumn_only: false)
+        indexes = connection.indexes(table_name)
+
+        message =
+          if multicolumn_only
+            "Iterating over multi-column indexes on #{table_name}"
+          else
+            "Iterating over indexes on #{table_name}"
+          end
+
+        log(message) do
+          indexes.each do |index|
+            case
+            when except.include?(index.name)
+              log("#{index.name} - ignored via the configuration; skipping")
+            when multicolumn_only && !index.columns.is_a?(Array)
+              log("#{index.name} - single-column index; skipping")
+            else
+              log("Index #{index.name} on #{table_name}") do
+                yield(index, indexes)
+              end
+            end
+          end
+        end
+      end
+
+      def each_attribute(model, except: [], type: nil)
+        log("Iterating over attributes of #{model.name}") do
+          connection.columns(model.table_name).each do |column|
+            case
+            when except.include?("#{model.name}.#{column.name}")
+              log("#{model.name}.#{column.name} - ignored via the configuration; skipping")
+            when type && !Array(type).include?(column.type)
+              log("#{model.name}.#{column.name} - ignored due to the #{column.type} type; skipping")
+            else
+              log("#{model.name}.#{column.name}") do
+                yield(column)
+              end
+            end
+          end
+        end
+      end
+
+      def each_column(table_name, only: nil, except: [])
+        log("Iterating over columns of #{table_name}") do
+          connection.columns(table_name).each do |column|
+            case
+            when except.include?("#{table_name}.#{column.name}")
+              log("#{column.name} - ignored via the configuration; skipping")
+            when only.nil? || only.include?(column.name)
+              log(column.name.to_s) do
+                yield(column)
+              end
+            end
+          end
+        end
+      end
+
+      def each_foreign_key(table_name)
+        log("Iterating over foreign keys on #{table_name}") do
+          connection.foreign_keys(table_name).each do |foreign_key|
+            log("#{foreign_key.name} - #{foreign_key.from_table}(#{foreign_key.options[:column]}) to #{foreign_key.to_table}(#{foreign_key.options[:primary_key]})") do # rubocop:disable Layout/LineLength
+              yield(foreign_key)
+            end
+          end
+        end
+      end
+
+      def each_table(except: [])
+        tables =
+          if ActiveRecord::VERSION::STRING >= "5.1"
+            connection.tables
+          else
+            connection.data_sources
+          end
+
+        log("Iterating over tables") do
+          tables.each do |table|
+            case
+            when except.include?(table)
+              log("#{table} - ignored via the configuration; skipping")
+            else
+              log(table) do
+                yield(table)
+              end
+            end
+          end
+        end
+      end
+
+      def each_association(model, except: [], type: [:has_many, :has_one, :belongs_to], has_scope: nil, through: nil)
+        type = Array(type)
+
+        log("Iterating over associations on #{model.name}") do
+          associations = []
+          type.each do |type1|
+            associations.concat(model.reflect_on_all_associations(type1))
+          end
+
+          associations.each do |association|
+            case
+            when except.include?("#{model.name}.#{association.name}")
+              log("#{model.name}.#{association.name} - ignored via the configuration; skipping")
+            when through && !association.is_a?(ActiveRecord::Reflection::ThroughReflection)
+              log("#{model.name}.#{association.name} - is not a through association; skipping")
+            when through == false && association.is_a?(ActiveRecord::Reflection::ThroughReflection)
+              log("#{model.name}.#{association.name} - is a through association; skipping")
+            when has_scope && association.scope.nil?
+              log("#{model.name}.#{association.name} - doesn't have a scope; skipping")
+            when has_scope == false && association.scope
+              log("#{model.name}.#{association.name} - has a scope; skipping")
+            else
+              log("#{association.macro} :#{association.name}") do
+                yield(association)
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -33,35 +33,36 @@ module ActiveRecordDoctor
       end
 
       def subindexes_of_multi_column_indexes
-        tables(except: config(:ignore_tables)).each do |table|
-          indexes = indexes(table)
-
-          indexes.each do |index|
-            next if config(:ignore_indexes).include?(index.name)
-
-            replacement_indexes = indexes.select do |other_index|
-              index != other_index && replaceable_with?(index, other_index)
+        log(__method__) do
+          each_table(except: config(:ignore_tables)) do |table|
+            each_index(table, except: config(:ignore_indexes), multicolumn_only: true) do |index, indexes|
+              replacement_indexes = indexes.select do |other_index|
+                index != other_index && replaceable_with?(index, other_index)
+              end
+
+              if replacement_indexes.empty?
+                log("Found no replacement indexes; skipping")
+                next
+              end
+
+              problem!(
+                extraneous_index: index.name,
+                replacement_indexes: replacement_indexes.map(&:name).sort
+              )
             end
-
-            next if replacement_indexes.empty?
-
-            problem!(
-              extraneous_index: index.name,
-              replacement_indexes: replacement_indexes.map(&:name).sort
-            )
           end
         end
       end
 
       def indexed_primary_keys
-        tables(except: config(:ignore_tables)).each do |table|
-          indexes(table).each do |index|
-            next if config(:ignore_indexes).include?(index.name)
-
-            primary_key = connection.primary_key(table)
-            next if index.columns != [primary_key] || index.where
-
-            problem!(extraneous_index: index.name, replacement_indexes: nil)
+        log(__method__) do
+          each_table(except: config(:ignore_tables)) do |table|
+            each_index(table, except: config(:ignore_indexes), multicolumn_only: true) do |index|
+              primary_key = connection.primary_key(table)
+              if index.columns == [primary_key] && index.where.nil?
+                problem!(extraneous_index: index.name, replacement_indexes: nil)
+              end
+            end
           end
         end
       end
@@ -90,10 +91,6 @@ module ActiveRecordDoctor
         lhs.columns.count <= rhs.columns.count &&
           rhs.columns[0...lhs.columns.count] == lhs.columns
       end
-
-      def indexes(table_name)
-        super.select { |index| index.columns.is_a?(Array) }
-      end
     end
   end
 end

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -25,11 +25,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          connection.columns(model.table_name).each do |column|
-            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes)) do |column|
             next unless column.type == :boolean
             next unless has_presence_validator?(model, column)
 

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -18,7 +18,7 @@ module ActiveRecordDoctor
 
       private
 
-      def message(model:, association:, problem:, associated_models:)
+      def message(model:, association:, problem:, associated_models:, associated_models_type:)
         associated_models.sort!
 
         models_part =
@@ -28,34 +28,62 @@ module ActiveRecordDoctor
             "models #{associated_models.join(', ')} have"
           end
 
+        if associated_models_type
+          models_part = "#{associated_models_type} #{models_part}"
+        end
+
         # rubocop:disable Layout/LineLength
         case problem
+        when :invalid_through
+          "ensure #{model}.#{association} is configured correctly - #{associated_models[0]}.#{association} may be undefined"
         when :suggest_destroy
-          "use `dependent: :destroy` or similar on #{model}.#{association} - the associated #{models_part} callbacks that are currently skipped"
+          "use `dependent: :destroy` or similar on #{model}.#{association} - associated #{models_part} callbacks that are currently skipped"
         when :suggest_delete
-          "use `dependent: :delete` or similar on #{model}.#{association} - the associated #{models_part} no callbacks and can be deleted without loading"
+          "use `dependent: :delete` or similar on #{model}.#{association} - associated #{models_part} no callbacks and can be deleted without loading"
         when :suggest_delete_all
-          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated #{models_part} no validations and can be deleted in bulk"
+          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated #{models_part} no callbacks and can be deleted in bulk"
         end
         # rubocop:enable Layout/LineLength
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          associations = model.reflect_on_all_associations(:has_many) +
-                         model.reflect_on_all_associations(:has_one) +
-                         model.reflect_on_all_associations(:belongs_to)
-
-          associations.each do |association|
-            next if config(:ignore_associations).include?("#{model.name}.#{association.name}")
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_association(model, except: config(:ignore_associations)) do |association|
+            # A properly configured :through association will have a non-nil
+            # source_reflection. If it's nil then it indicates the :through
+            # model lacks the next leg in the :through relationship. For
+            # instance, if user has many comments through posts then a nil
+            # source_reflection means that Post doesn't define +has_many :comments+.
+            if through?(association) && association.source_reflection.nil?
+              log("through association with nil source_reflection")
+
+              through_association = model.reflect_on_association(association.options.fetch(:through))
+              association_on_join_model = through_association.klass.reflect_on_association(association.name)
+
+              # We report a problem only if the +has_many+ association mentioned
+              # above is actually missing. We let the detector continue in other
+              # cases, risking an exception, as the absence of source_reflection
+              # must be caused by something else in those cases. Each further
+              # exception will be handled on a case-by-case basis.
+              if association_on_join_model.nil?
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: :invalid_through,
+                  associated_models: [through_association.klass.name],
+                  associated_models_type: "join"
+                )
+                next
+              end
+            end
 
-            associated_models =
+            associated_models, associated_models_type =
               if association.polymorphic?
-                models_having(as: association.name)
+                [models_having_association_with_options(as: association.name), nil]
+              elsif through?(association)
+                [[association.source_reflection.active_record], "join"]
               else
-                [association.klass]
+                [[association.klass], nil]
               end
 
             deletable_models, destroyable_models = associated_models.partition { |klass| deletable?(klass) }
@@ -68,17 +96,27 @@ module ActiveRecordDoctor
                 else raise("unsupported association type #{association.macro}")
                 end
 
-              problem!(model: model.name, association: association.name, problem: suggestion,
-                       associated_models: deletable_models.map(&:name))
+              problem!(
+                model: model.name,
+                association: association.name,
+                problem: suggestion,
+                associated_models: deletable_models.map(&:name),
+                associated_models_type: associated_models_type
+              )
             elsif callback_action(association) == :skip && destroyable_models.present?
-              problem!(model: model.name, association: association.name, problem: :suggest_destroy,
-                       associated_models: destroyable_models.map(&:name))
+              problem!(
+                model: model.name,
+                association: association.name,
+                problem: :suggest_destroy,
+                associated_models: destroyable_models.map(&:name),
+                associated_models_type: associated_models_type
+              )
             end
           end
         end
       end
 
-      def models_having(as:)
+      def models_having_association_with_options(as:)
         models.select do |model|
           associations = model.reflect_on_all_associations(:has_one) +
                          model.reflect_on_all_associations(:has_many)
@@ -108,6 +146,10 @@ module ActiveRecordDoctor
           end
       end
 
+      def through?(reflection)
+        reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      end
+
       def defines_destroy_callbacks?(model)
         # Destroying an associated model involves loading it first hence
         # initialize and find are present. If they are defined on the model

data/lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -31,14 +31,9 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          connection.columns(model.table_name).each do |column|
-            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
-            next if ![:string, :text].include?(column.type)
-
-            model_maximum = maximum_allowed_by_validations(model)
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes), type: [:string, :text]) do |column|
+            model_maximum = maximum_allowed_by_validations(model, column.name.to_sym)
             next if model_maximum == column.limit
 
             problem!(
@@ -52,9 +47,11 @@ module ActiveRecordDoctor
         end
       end
 
-      def maximum_allowed_by_validations(model)
+      def maximum_allowed_by_validations(model, column)
         length_validator = model.validators.find do |validator|
-          validator.kind == :length && validator.options.include?(:maximum)
+          validator.kind == :length &&
+            validator.options.include?(:maximum) &&
+            validator.attributes.include?(column)
         end
         length_validator ? length_validator.options[:maximum] : nil
       end

data/lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -18,25 +18,32 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, column:)
+      def message(from_table:, from_column:, from_type:, to_table:, to_column:, to_type:)
         # rubocop:disable Layout/LineLength
-        "#{table}.#{column} references a column of different type - foreign keys should be of the same type as the referenced column"
+        "#{from_table}.#{from_column} is a foreign key of type #{from_type} and references #{to_table}.#{to_column} of type #{to_type} - foreign keys should be of the same type as the referenced column"
         # rubocop:enable Layout/LineLength
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
-          connection.foreign_keys(table).each do |foreign_key|
+        each_table(except: config(:ignore_tables)) do |table|
+          each_foreign_key(table) do |foreign_key|
             from_column = column(table, foreign_key.column)
 
             next if config(:ignore_columns).include?("#{table}.#{from_column.name}")
 
             to_table = foreign_key.to_table
-            primary_key = primary_key(to_table)
-
-            next if from_column.sql_type == primary_key.sql_type
-
-            problem!(table: table, column: from_column.name)
+            to_column = column(to_table, foreign_key.primary_key)
+
+            next if from_column.sql_type == to_column.sql_type
+
+            problem!(
+              from_table: table,
+              from_column: from_column.name,
+              from_type: from_column.sql_type,
+              to_table: to_table,
+              to_column: to_column.name,
+              to_type: to_column.sql_type
+            )
           end
         end
       end

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -23,10 +23,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
-          connection.columns(table).each do |column|
-            next if config(:ignore_columns).include?("#{table}.#{column.name}")
-
+        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.

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -23,8 +23,7 @@ module ActiveRecordDoctor
       end
 
       def detect
-        table_models = models.group_by(&:table_name)
-        table_models.delete_if { |_table, models| !models.first.table_exists? }
+        table_models = models.select(&:table_exists?).group_by(&:table_name)
 
         table_models.each do |table, models|
           next if config(:ignore_tables).include?(table)
@@ -50,19 +49,22 @@ module ActiveRecordDoctor
       end
 
       def non_null_needed?(model, column)
-        # A foreign key can be validates via the column name (e.g. company_id)
-        # or the association name (e.g. company). We collect the allowed names
-        # in an array to check for their presence in the validator definition
-        # in one go.
-        attribute_name_forms = [column.name.to_sym]
         belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
-          reflection.foreign_key == column.name
+          reflection.foreign_key == column.name ||
+            (reflection.polymorphic? && reflection.foreign_type == column.name)
         end
-        attribute_name_forms << belongs_to.name.to_sym if belongs_to
 
-        model.validators.any? do |validator|
+        required_presence_validators(model).any? do |validator|
+          attributes = validator.attributes
+
+          attributes.include?(column.name.to_sym) ||
+            (belongs_to && attributes.include?(belongs_to.name.to_sym))
+        end
+      end
+
+      def required_presence_validators(model)
+        model.validators.select do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
-            (validator.attributes & attribute_name_forms).present? &&
             !validator.options[:allow_nil] &&
             !validator.options[:if] &&
             !validator.options[:unless]