database_consistency 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef796f91309cb17dcba40b0b2af43569e1f938ba1c8ddb4be230a2f470d4a291
-  data.tar.gz: 122b3e9154b464def4ee5533b9e4401bc25057ffac9d51cec2cf214bc1ef9534
+  metadata.gz: 0cb421a3fbd1c94df1816ecaf52487578c2a68c2aa13f384d1f80a9c68b35613
+  data.tar.gz: 5a38ad0d44e448e08e7474e74ecd0f934f0b9bf86e2fe43a80c2bb4540b154e8
 SHA512:
-  metadata.gz: 9711216a1cbd3a46ca8cef1dd142eef6c0ba590431faed0a5bf74f1fd83121317fec341265867c85b93e5b18112dbebd1673e982cb7d641edf8cf5bfa0b2af20
-  data.tar.gz: c1ca40e919cc496157999965b5edc3bbc51c67ab3e11fc55bc06ceb5a3503db66d7197ab420bc0dc38c09fb05be7323e26fc2d85301b32987e05fb3786a5e5a8
+  metadata.gz: a6195f162dac4165dd70ce10fddc1dde43527f2d3dd845f9a4f2f4b9f0def589ed125fbe5cce3a5e61eb80c91ccefb609de4bc42ea0dcbe4ff26edd556522884
+  data.tar.gz: 47ebc91829df9bc38a2f518b0b5d4b938a51d79d441984c257c9fa7429d12cc22d3d6184029396d29c0e422ac890c9311391ae9cbc6e2d052fae33e22694f11c

data/lib/database_consistency/checkers/base_checker.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Checkers
+    # The base class for checkers
+    class BaseChecker
+      def initialize(table_or_model, column_or_attribute, opts = {})
+        @table_or_model = table_or_model
+        @column_or_attribute = column_or_attribute
+        @opts = opts
+      end
+
+      # @return [Hash]
+      def report
+        @report ||= check
+      end
+
+      # @param [DatabaseConsistency::Configuration] configuration
+      def enabled?(configuration)
+        configuration.enabled?(checker_name, table_or_model_name, column_or_attribute_name)
+      end
+
+      private
+
+      attr_reader :table_or_model, :column_or_attribute, :opts
+
+      # @return [String]
+      def checker_name
+        @checker_name ||= self.class.name.split('::').last
+      end
+
+      def table_or_model_name
+        raise NotImplementedError
+      end
+
+      def column_or_attribute_name
+        raise NotImplementedError
+      end
+
+      # @return [Hash]
+      def report_template(status, message = nil)
+        OpenStruct.new(
+          checker_name: checker_name,
+          table_or_model_name: table_or_model_name,
+          column_or_attribute_name: column_or_attribute_name,
+          status: status,
+          message: message
+        )
+      end
+    end
+  end
+end

data/lib/database_consistency/checkers/null_constraint_checker.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Checkers
+    # This class checks missing presence validator
+    class NullConstraintChecker < BaseChecker
+      # Message templates
+      VALIDATOR_MISSING = 'is required but do not have presence validator'
+
+      private
+
+      # Table of possible statuses
+      # | validation | database | status |
+      # | ---------- | -------- | ------ |
+      # | missed     | required | fail   |
+      #
+      # We skip check when:
+      #  - column hasn't null constraint
+      #  - column has default value
+      #  - column is a primary key
+      #  - column is a timestamp
+      #  - presence validation exists
+      #  - inclusion validation exists
+      #  - belongs_to reflection exists with given column as foreign key or foreign type
+      def check
+        return if skip? ||
+                  validator?(ActiveModel::Validations::PresenceValidator) ||
+                  validator?(ActiveModel::Validations::InclusionValidator) ||
+                  belongs_to_reflection?
+
+        report_template(:fail, VALIDATOR_MISSING)
+      end
+
+      def column_or_attribute_name
+        column_or_attribute.name.to_s
+      end
+
+      def table_or_model_name
+        table_or_model.name.to_s
+      end
+
+      def skip?
+        column_or_attribute.null ||
+          !column_or_attribute.default.nil? ||
+          column_or_attribute.name == table_or_model.primary_key ||
+          timestamp_field?
+      end
+
+      def timestamp_field?
+        table_or_model.record_timestamps? && %w[created_at updated_at].include?(column_or_attribute.name)
+      end
+
+      def validator?(validator_class)
+        table_or_model.validators.grep(validator_class).any? do |validator|
+          Helper.check_inclusion?(validator.attributes, column_or_attribute.name)
+        end
+      end
+
+      def belongs_to_reflection?
+        table_or_model.reflect_on_all_associations.grep(ActiveRecord::Reflection::BelongsToReflection).any? do |r|
+          Helper.check_inclusion?([r.foreign_key, r.foreign_type], column_or_attribute.name)
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/{comparators/presence_comparator.rb → checkers/presence_validation_checker.rb}

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module DatabaseConsistency
-  module Comparators
-    # The comparator class for {{ActiveModel::Validations::PresenceValidator}}
-    class PresenceComparator < BaseComparator
+  module Checkers
+    # This class checks PresenceValidator
+    class PresenceValidationChecker < BaseChecker
       WEAK_OPTIONS = %i[allow_nil allow_blank if unless].freeze
       # Message templates
-      CONSTRAINT_MISSING = 'should be required in the database'.freeze
-      POSSIBLE_NULL = 'is required but possible null value insert'.freeze
+      CONSTRAINT_MISSING = 'should be required in the database'
+      POSSIBLE_NULL = 'is required but possible null value insert'
+
+      private
 
       # Table of possible statuses
       # | allow_nil/allow_blank/if/unless | database | status |
@@ -14,23 +18,38 @@ module DatabaseConsistency
       # | at least one provided           | optional | ok     |
       # | all missed                      | required | ok     |
       # | all missed                      | optional | fail   |
-      def compare
+      #
+      # We skip check when:
+      #  - there is no column in the database with given name
+      def check
+        return unless column
+
         can_be_null = column.null
         has_weak_option = validator.options.slice(*WEAK_OPTIONS).any?
 
         if can_be_null == has_weak_option
-          result(:ok, message)
+          report_template(:ok)
         elsif can_be_null
-          result(:fail, message(CONSTRAINT_MISSING))
+          report_template(:fail, CONSTRAINT_MISSING)
         else
-          result(:fail, message(POSSIBLE_NULL))
+          report_template(:fail, POSSIBLE_NULL)
         end
       end
 
-      private
+      def column
+        @column ||= Helper.find_field(table_or_model, column_or_attribute.to_s)
+      end
+
+      def column_or_attribute_name
+        column_or_attribute.to_s
+      end
+
+      def table_or_model_name
+        table_or_model.name.to_s
+      end
 
-      def message(template = nil)
-        Helper.message(model, column, template)
+      def validator
+        opts[:validator]
       end
     end
   end

data/lib/database_consistency/configuration.rb

@@ -1,19 +1,38 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module DatabaseConsistency
   # The class to access configuration options
   class Configuration
-    def initialize(filepath = nil)
-      @configuration = if filepath
+    CONFIGURATION_PATH = '.database_consistency.yml'
+
+    def initialize(filepath = CONFIGURATION_PATH)
+      @configuration = if filepath && File.exist?(filepath)
                          YAML.load_file(filepath)
                        else
                          {}
                        end
     end
 
-    def enabled?(processor)
-      name = processor.to_s.split('::').last
-      @configuration[name].nil? || @configuration[name] == true
+    # @return [Boolean]
+    def enabled?(*path)
+      current = configuration
+
+      path.each do |key|
+        current = current[key.to_s]
+        return true unless current.is_a?(Hash)
+
+        next if current['enabled'].nil?
+
+        return false unless current['enabled']
+      end
+
+      true
     end
+
+    private
+
+    attr_reader :configuration
   end
 end

data/lib/database_consistency/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DatabaseConsistency
   # The module contains helper methods
   module Helper
@@ -25,13 +27,6 @@ module DatabaseConsistency
       model.columns.select.find { |field| field.name == attribute }
     end
 
-    # @return [String]
-    def message(model, column, template = nil)
-      str = "column #{column.name} of table #{model.table_name} of model #{model.name}"
-      str += " #{template}" if template
-      str
-    end
-
     # @return [Boolean]
     def check_inclusion?(array, element)
       array.include?(element.to_s) || array.include?(element.to_sym)

data/lib/database_consistency/processors/base_processor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  # The module for processors
+  module Processors
+    def self.reports(configuration)
+      [ModelsProcessor, TablesProcessor].flat_map do |processor|
+        processor.new(configuration).reports
+      end
+    end
+
+    # The base class for processors
+    class BaseProcessor
+      attr_reader :configuration
+
+      # @param [DatabaseConsistency::Configuration] configuration
+      def initialize(configuration = nil)
+        @configuration = configuration || Configuration.new
+      end
+
+      # @return [Array<Hash>]
+      def reports
+        @reports ||= check
+      end
+
+      private
+
+      def check
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/database_consistency/processors/models_processor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Processors
+    # The class to process all comparators
+    class ModelsProcessor < BaseProcessor
+      CHECKERS = {
+        presence: Checkers::PresenceValidationChecker
+      }.freeze
+
+      private
+
+      # @return [Array<Hash>]
+      def check
+        Helper.parent_models.flat_map do |model|
+          model.validators.flat_map do |validator|
+            next unless (checker_class = CHECKERS[validator.kind])
+
+            validator.attributes.map do |attribute|
+              checker = checker_class.new(model, attribute, validator: validator)
+              checker.report if checker.enabled?(configuration)
+            end
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/database_consistency/processors/tables_processor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Processors
+    # The class to process missing validators
+    class TablesProcessor < BaseProcessor
+      CHECKERS = [
+        Checkers::NullConstraintChecker
+      ].freeze
+
+      private
+
+      def check
+        Helper.parent_models.flat_map do |model|
+          model.columns.flat_map do |column|
+            CHECKERS.map do |checker_class|
+              checker = checker_class.new(model, column)
+              checker.report if checker.enabled?(configuration)
+            end
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/database_consistency/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DatabaseConsistency
-  VERSION = '0.2.5'.freeze
+  VERSION = '0.3.0'
 end

data/lib/database_consistency/writers/base_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DatabaseConsistency
   module Writers
     # The base class for writers
@@ -10,7 +12,7 @@ module DatabaseConsistency
       end
 
       def write?(status)
-        status == :fail
+        status == :fail || debug?
       end
 
       def debug?

data/lib/database_consistency/writers/simple_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DatabaseConsistency
   # The module contains formatters
   module Writers
@@ -12,16 +14,12 @@ module DatabaseConsistency
           next unless write?(result[:status])
 
           line(result)
-        end.tap(&:compact!).map(&:lstrip).delete_if(&:empty?).join(delimiter)
-      end
-
-      def delimiter
-        debug? ? "\n\n" : "\n"
+        end.tap(&:compact!).map(&:lstrip).delete_if(&:empty?).join("\n")
       end
 
       def line(result)
-        "#{result[:status]} #{result[:message]}".tap do |str|
-          str.concat " #{result[:opts].inspect}" if debug?
+        "#{result.status} #{result.table_or_model_name} #{result.column_or_attribute_name} #{result.message}".tap do |s|
+          s.concat " (checker: #{result.checker_name})" if debug?
         end
       end
     end

data/lib/database_consistency.rb

@@ -1,34 +1,31 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
 require 'database_consistency/version'
-require 'database_consistency/report'
 require 'database_consistency/helper'
 require 'database_consistency/configuration'
 
 require 'database_consistency/writers/base_writer'
 require 'database_consistency/writers/simple_writer'
 
-require 'database_consistency/comparators/base_comparator'
-require 'database_consistency/comparators/presence_comparator'
-require 'database_consistency/validators_processor'
+require 'database_consistency/checkers/base_checker'
+require 'database_consistency/checkers/presence_validation_checker'
+require 'database_consistency/checkers/null_constraint_checker'
 
-require 'database_consistency/column_verifiers/base_verifier'
-require 'database_consistency/column_verifiers/presence_missing_verifier'
-require 'database_consistency/database_processor'
+require 'database_consistency/processors/base_processor'
+require 'database_consistency/processors/models_processor'
+require 'database_consistency/processors/tables_processor'
 
 # The root module
 module DatabaseConsistency
-  CONFIGURATION_PATH = '.database_consistency.yml'.freeze
-
-  PROCESSORS = [
-    ValidatorsProcessor,
-    DatabaseProcessor
-  ].freeze
-
   class << self
     def run
       Helper.load_environment!
 
+      configuration = Configuration.new
+      reports = Processors.reports(configuration)
+
       Writers::SimpleWriter.write(
         reports,
         ENV['LOG_LEVEL'] || 'INFO'
@@ -36,21 +33,5 @@ module DatabaseConsistency
 
       reports.empty? ? 0 : 1
     end
-
-    def enabled_processors
-      @enabled_processors ||= PROCESSORS.select { |processor| configuration.enabled?(processor) }
-    end
-
-    def reports
-      @reports ||= enabled_processors.map(&:new).flat_map(&:reports)
-    end
-
-    def configuration
-      @configuration ||= if File.exist?(CONFIGURATION_PATH)
-                           Configuration.new(CONFIGURATION_PATH)
-                         else
-                           Configuration.new
-                         end
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-24 00:00:00.000000000 Z
+date: 2019-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -110,15 +110,14 @@ extra_rdoc_files: []
 files:
 - bin/database_consistency
 - lib/database_consistency.rb
-- lib/database_consistency/column_verifiers/base_verifier.rb
-- lib/database_consistency/column_verifiers/presence_missing_verifier.rb
-- lib/database_consistency/comparators/base_comparator.rb
-- lib/database_consistency/comparators/presence_comparator.rb
+- lib/database_consistency/checkers/base_checker.rb
+- lib/database_consistency/checkers/null_constraint_checker.rb
+- lib/database_consistency/checkers/presence_validation_checker.rb
 - lib/database_consistency/configuration.rb
-- lib/database_consistency/database_processor.rb
 - lib/database_consistency/helper.rb
-- lib/database_consistency/report.rb
-- lib/database_consistency/validators_processor.rb
+- lib/database_consistency/processors/base_processor.rb
+- lib/database_consistency/processors/models_processor.rb
+- lib/database_consistency/processors/tables_processor.rb
 - lib/database_consistency/version.rb
 - lib/database_consistency/writers/base_writer.rb
 - lib/database_consistency/writers/simple_writer.rb

data/lib/database_consistency/column_verifiers/base_verifier.rb

@@ -1,23 +0,0 @@
-module DatabaseConsistency
-  module ColumnVerifiers
-    # The base class for column verifiers
-    class BaseVerifier
-      attr_reader :model, :column
-
-      delegate :result, to: :report
-
-      def initialize(model, column)
-        @model = model
-        @column = column
-      end
-
-      def report
-        Report.new(column: column)
-      end
-
-      def self.verify(model, column)
-        new(model, column).verify
-      end
-    end
-  end
-end

data/lib/database_consistency/column_verifiers/presence_missing_verifier.rb

@@ -1,45 +0,0 @@
-module DatabaseConsistency
-  module ColumnVerifiers
-    # This class verifies that column needs a presence validator
-    class PresenceMissingVerifier < BaseVerifier
-      VALIDATOR_MISSING = 'is required but do not have presence validator'.freeze
-
-      def verify
-        return if skip? || presence_validator? || inclusion_validator? || belongs_to_reflection?
-
-        result(:fail, Helper.message(model, column, VALIDATOR_MISSING))
-      end
-
-      private
-
-      def skip?
-        column.null ||
-          !column.default.nil? ||
-          column.name == model.primary_key ||
-          timestamp_field?
-      end
-
-      def timestamp_field?
-        model.record_timestamps? && %w[created_at updated_at].include?(column.name)
-      end
-
-      def presence_validator?
-        model.validators.grep(ActiveModel::Validations::PresenceValidator).any? do |validator|
-          Helper.check_inclusion?(validator.attributes, column.name)
-        end
-      end
-
-      def inclusion_validator?
-        model.validators.grep(ActiveModel::Validations::InclusionValidator).any? do |validator|
-          Helper.check_inclusion?(validator.attributes, column.name)
-        end
-      end
-
-      def belongs_to_reflection?
-        model.reflect_on_all_associations.grep(ActiveRecord::Reflection::BelongsToReflection).any? do |reflection|
-          Helper.check_inclusion?([reflection.foreign_key, reflection.foreign_type], column.name)
-        end
-      end
-    end
-  end
-end

data/lib/database_consistency/comparators/base_comparator.rb

@@ -1,24 +0,0 @@
-module DatabaseConsistency
-  module Comparators
-    # The base class for comparators
-    class BaseComparator
-      attr_reader :validator, :model, :column
-
-      delegate :result, to: :report
-
-      def initialize(validator, model, column)
-        @validator = validator
-        @model = model
-        @column = column
-      end
-
-      def report
-        Report.new(validator: validator, column: column)
-      end
-
-      def self.compare(validator, model, column)
-        new(validator, model, column).compare
-      end
-    end
-  end
-end

data/lib/database_consistency/database_processor.rb

@@ -1,18 +0,0 @@
-module DatabaseConsistency
-  # The class to process missing validators
-  class DatabaseProcessor
-    VERIFIERS = [
-      ColumnVerifiers::PresenceMissingVerifier
-    ].freeze
-
-    def reports
-      Helper.parent_models.flat_map do |model|
-        model.columns.flat_map do |column|
-          VERIFIERS.map do |verifier|
-            verifier.verify(model, column)
-          end
-        end
-      end.compact
-    end
-  end
-end

data/lib/database_consistency/report.rb

@@ -1,17 +0,0 @@
-module DatabaseConsistency
-  # This class outputs the report result
-  class Report
-    attr_reader :opts
-
-    def initialize(opts = {})
-      @opts = opts
-    end
-
-    def result(status, message)
-      {
-        status: status,
-        message: message
-      }.tap { |hash| hash[:opts] = opts unless opts.empty? }
-    end
-  end
-end

data/lib/database_consistency/validators_processor.rb

@@ -1,22 +0,0 @@
-module DatabaseConsistency
-  # The class to process all comparators
-  class ValidatorsProcessor
-    COMPARATORS = {
-      presence: DatabaseConsistency::Comparators::PresenceComparator
-    }.freeze
-
-    def reports
-      Helper.parent_models.flat_map do |model|
-        model.validators.flat_map do |validator|
-          next unless (comparator = COMPARATORS[validator.kind])
-
-          validator.attributes.map do |attribute|
-            next unless (column = Helper.find_field(model, attribute.to_s))
-
-            comparator.compare(validator, model, column)
-          end
-        end
-      end.compact
-    end
-  end
-end