database_validations 0.8.10 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c934b2c71117e26cc8493d7eafb35a681cb54f77bb6a1ad7d9ba0ec309664817
-  data.tar.gz: 7b7e34001d44eac5b818d756288ecb5e5d7f33147d5f8bbc07a3e54b0de6287c
+  metadata.gz: 70578fbf45115b1b0a349f2676b2c1a689f2aa8d29da2da189da263306c0b333
+  data.tar.gz: f6fc66d339e488cccdf750103637543ecd39d34a0a84366efa2382addcde6aee
 SHA512:
-  metadata.gz: 544cee2e2edf40aec5a25bfdc789df6324d07120997a1a68b366eac75152eeb095ca9cfb3758c32842e189da2ad5306e4530faaa24fa2ecbf44c93c44995e2c9
-  data.tar.gz: 3e006dfe1110c3758a3a971a2db45660a73427e6b9007d140f1e338d8dd02bd099c5a9cd29f78b8018c1f541c8c67f4bd064a845bbbf5bb6f1a18ff21d6d679c
+  metadata.gz: 6d40cf1b7d776cf984846f9cef85f1969271d619ae4ee9b9127fe67307c8983eb0ce385883541394932d9cc1f88a2e69fccdf5ff6b800ee06c5a1f5710b21495
+  data.tar.gz: 1e94c35ae4a40a56e275b6bad79a05cf0c3f29b735cf37495c2fb5e9013d2929ab0a54f025c6221a5fa8179a26d3660c9518ba8d5c1f4310ea3832b4ab4cdb28

data/lib/database_validations.rb

@@ -4,18 +4,21 @@ require 'database_validations/version'
 
 require 'database_validations/rails/railtie' if defined?(Rails)
 
-require 'database_validations/lib/validates_db_uniqueness_of/db_uniqueness_validator'
-require 'database_validations/lib/validates_db_uniqueness_of/uniqueness_handlers'
-require 'database_validations/lib/validates_db_uniqueness_of/uniqueness_options'
+require 'database_validations/lib/checkers/db_uniqueness_validator'
+require 'database_validations/lib/checkers/db_presence_validator'
 
-require 'database_validations/lib/db_belongs_to/db_presence_validator'
-require 'database_validations/lib/db_belongs_to/belongs_to_handlers'
-require 'database_validations/lib/db_belongs_to/belongs_to_options'
+require 'database_validations/lib/validators/db_uniqueness_validator'
+require 'database_validations/lib/validators/db_presence_validator'
 
-require 'database_validations/lib/rescuer'
-require 'database_validations/lib/options_storage'
+require 'database_validations/lib/storage'
+require 'database_validations/lib/attribute_validator'
+require 'database_validations/lib/key_generator'
+require 'database_validations/lib/uniqueness_key_extractor'
+require 'database_validations/lib/presence_key_extractor'
+require 'database_validations/lib/validations'
 require 'database_validations/lib/errors'
-require 'database_validations/lib/helpers'
+require 'database_validations/lib/rescuer'
+require 'database_validations/lib/injector'
 require 'database_validations/lib/adapters'
 
 module DatabaseValidations

data/lib/database_validations/lib/adapters/base_adapter.rb

@@ -31,22 +31,6 @@ module DatabaseValidations
         foreign_keys.find { |foreign_key| foreign_key.column.to_s == column.to_s }
       end
 
-      # @return [Symbol]
-      def adapter_name
-        self.class::ADAPTER
-      end
-
-      # @param [Symbol] option_name
-      # @return [Boolean]
-      def support_option?(option_name)
-        supported_options.include?(option_name.to_sym)
-      end
-
-      # @return [Array<Symbol>]
-      def supported_options
-        self.class::SUPPORTED_OPTIONS
-      end
-
       # @return [String]
       def table_name
         model.table_name

data/lib/database_validations/lib/adapters/mysql_adapter.rb

@@ -1,7 +1,6 @@
 module DatabaseValidations
   module Adapters
     class MysqlAdapter < BaseAdapter
-      SUPPORTED_OPTIONS = %i[scope message if unless index_name].freeze
       ADAPTER = :mysql2
 
       class << self

data/lib/database_validations/lib/adapters/postgresql_adapter.rb

@@ -1,7 +1,6 @@
 module DatabaseValidations
   module Adapters
     class PostgresqlAdapter < BaseAdapter
-      SUPPORTED_OPTIONS = %i[scope message where if unless index_name case_sensitive].freeze
       ADAPTER = :postgresql
 
       class << self

data/lib/database_validations/lib/adapters/sqlite_adapter.rb

@@ -1,7 +1,6 @@
 module DatabaseValidations
   module Adapters
     class SqliteAdapter < BaseAdapter
-      SUPPORTED_OPTIONS = %i[scope message if unless].freeze
       ADAPTER = :sqlite3
 
       class << self

data/lib/database_validations/lib/attribute_validator.rb

@@ -0,0 +1,3 @@
+module DatabaseValidations
+  AttributeValidator = Struct.new(:attribute, :validator)
+end

data/lib/database_validations/lib/checkers/db_presence_validator.rb

@@ -0,0 +1,36 @@
+module DatabaseValidations
+  module Checkers
+    class DbPresenceValidator
+      attr_reader :validator
+
+      # @param [DatabaseValidations::DbPresenceValidator]
+      def self.validate!(validator)
+        new(validator).validate!
+      end
+
+      # @param [DatabaseValidations::DbPresenceValidator]
+      def initialize(validator)
+        @validator = validator
+      end
+
+      def validate!
+        validate_foreign_keys! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
+      end
+
+      private
+
+      def validate_foreign_keys! # rubocop:disable Metrics/AbcSize
+        adapter = Adapters::BaseAdapter.new(validator.klass)
+
+        validator.attributes.each do |attribute|
+          reflection = validator.klass._reflect_on_association(attribute)
+
+          next unless reflection
+          next if adapter.find_foreign_key_by_column(reflection.foreign_key)
+
+          raise Errors::ForeignKeyNotFound.new(reflection.foreign_key, adapter.foreign_keys)
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/lib/checkers/db_uniqueness_validator.rb

@@ -0,0 +1,47 @@
+module DatabaseValidations
+  module Checkers
+    class DbUniquenessValidator
+      attr_reader :validator
+
+      # @param [DatabaseValidations::DbUniquenessValidator]
+      def self.validate!(validator)
+        new(validator).validate!
+      end
+
+      # @param [DatabaseValidations::DbUniquenessValidator]
+      def initialize(validator)
+        @validator = validator
+      end
+
+      def validate!
+        validate_index_usage!
+
+        validate_indexes! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
+      end
+
+      private
+
+      def valid_index?(columns, index)
+        index_columns_size = index.columns.is_a?(Array) ? index.columns.size : (index.columns.count(',') + 1)
+
+        (columns.size == index_columns_size) && (validator.where.nil? == index.where.nil?)
+      end
+
+      def validate_index_usage!
+        return unless validator.index_name.present? && validator.attributes.size > 1
+
+        raise ArgumentError, "When index_name is provided validator can have only one attribute. See #{validator.inspect}"
+      end
+
+      def validate_indexes! # rubocop:disable Metrics/AbcSize
+        adapter = Adapters::BaseAdapter.new(validator.klass)
+
+        validator.attributes.map do |attribute|
+          columns = KeyGenerator.unify_columns(attribute, validator.options[:scope])
+          index = validator.index_name ? adapter.find_index_by_name(validator.index_name.to_s) : adapter.find_index(columns, validator.where) # rubocop:disable Metrics/LineLength
+          raise Errors::IndexNotFound.new(columns, validator.where, validator.index_name, adapter.indexes, adapter.table_name) unless index && valid_index?(columns, index) # rubocop:disable Metrics/LineLength
+        end
+      end
+    end
+  end
+end

data/lib/database_validations/lib/errors.rb

@@ -41,17 +41,6 @@ module DatabaseValidations
       end
     end
 
-    class OptionIsNotSupported < Base
-      attr_reader :option, :database, :supported_options
-
-      def initialize(option, database, supported_options)
-        @option = option
-        @database = database
-        @supported_options = supported_options
-        super "Option #{self.option} is not supported for #{self.database}. Supported options are: #{self.supported_options}"
-      end
-    end
-
     class ForeignKeyNotFound < Base
       attr_reader :column, :foreign_keys
 

data/lib/database_validations/lib/injector.rb

@@ -0,0 +1,13 @@
+module DatabaseValidations
+  module Injector
+    module_function
+
+    # @param [ActiveRecord::Base] model
+    def inject(model)
+      return if model.method_defined?(:valid_without_database_validations?)
+
+      model.__send__(:alias_method, :valid_without_database_validations?, :valid?)
+      model.include(DatabaseValidations::Validations)
+    end
+  end
+end

data/lib/database_validations/lib/key_generator.rb

@@ -0,0 +1,32 @@
+module DatabaseValidations
+  module KeyGenerator
+    module_function
+
+    # @param [String] index_name
+    #
+    # @return [String]
+    def for_unique_index(index_name)
+      generate_key(:unique_index, index_name)
+    end
+
+    # @return [String]
+    def for_db_uniqueness(*columns)
+      generate_key(:db_uniqueness, columns)
+    end
+
+    # @return [String]
+    def for_db_presence(column)
+      generate_key(:db_presence, column)
+    end
+
+    # @return [String]
+    def generate_key(type, *args)
+      [type, *unify_columns(args)].join('__')
+    end
+
+    # @return [String]
+    def unify_columns(*args)
+      args.flatten.compact.map(&:to_s).sort
+    end
+  end
+end

data/lib/database_validations/lib/presence_key_extractor.rb

@@ -0,0 +1,18 @@
+module DatabaseValidations
+  module PresenceKeyExtractor
+    module_function
+
+    # @param [DatabaseValidations::DbPresenceValidator]
+    #
+    # @return [Hash]
+    def attribute_by_key(validator)
+      validator.attributes.map do |attribute|
+        reflection = validator.klass._reflect_on_association(attribute)
+
+        key = reflection ? reflection.foreign_key : attribute
+
+        [KeyGenerator.for_db_presence(key), attribute]
+      end.to_h
+    end
+  end
+end

data/lib/database_validations/lib/rescuer.rb

@@ -1,31 +1,36 @@
 module DatabaseValidations
   module Rescuer
-    extend ActiveSupport::Concern
+    module_function
 
-    included do
-      alias_method :validate, :valid?
-    end
-
-    attr_accessor :_database_validations_fallback
+    def handled?(instance, error)
+      Storage.prepare(instance.class) unless Storage.prepared?(instance.class)
 
-    def valid?(context = nil)
-      self._database_validations_fallback = true
-      super(context)
+      case error
+      when ActiveRecord::RecordNotUnique
+        process(instance, error, for_unique_index: :unique_index_name, for_db_uniqueness: :unique_error_columns)
+      when ActiveRecord::InvalidForeignKey
+        process(instance, error, for_db_presence: :foreign_key_error_column)
+      else false
+      end
     end
 
-    def create_or_update(*args, &block)
-      self._database_validations_fallback = false
-      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
-    rescue ActiveRecord::InvalidForeignKey, ActiveRecord::RecordNotUnique => error
-      raise error unless Helpers.handle_error!(self, error)
+    def process(instance, error, key_types)
+      adapter = Adapters.factory(instance.class)
 
-      raise ActiveRecord::RecordInvalid, self
-    end
+      keys = key_types.map do |key_generator, error_processor|
+        KeyGenerator.public_send(key_generator, adapter.public_send(error_processor, error.message))
+      end
+
+      keys.each do |key|
+        attribute_validator = instance._db_validators[key]
 
-    private
+        if attribute_validator
+          attribute_validator.validator.apply_error(instance, attribute_validator.attribute)
+          return true
+        end
+      end
 
-    def perform_validations(options = {})
-      options[:validate] == false || valid_without_database_validations?(options[:context])
+      false
     end
   end
 end

data/lib/database_validations/lib/storage.rb

@@ -0,0 +1,28 @@
+module DatabaseValidations
+  module Storage
+    module_function
+
+    def prepare(model)
+      model.class_attribute :_db_validators, instance_writer: false
+      model._db_validators = {}
+
+      model.validators.each do |validator|
+        case validator
+        when DbUniquenessValidator then process(validator, UniquenessKeyExtractor, model)
+        when DbPresenceValidator then process(validator, PresenceKeyExtractor, model)
+        else next
+        end
+      end
+    end
+
+    def process(validator, extractor, model)
+      extractor.attribute_by_key(validator).each do |key, attribute|
+        model._db_validators[key] = AttributeValidator.new(attribute, validator)
+      end
+    end
+
+    def prepared?(model)
+      model.respond_to?(:_db_validators)
+    end
+  end
+end

data/lib/database_validations/lib/uniqueness_key_extractor.rb

@@ -0,0 +1,38 @@
+module DatabaseValidations
+  module UniquenessKeyExtractor
+    module_function
+
+    # @param [DatabaseValidations::DbUniquenessValidator]
+    #
+    # @return [Hash]
+    def attribute_by_columns_keys(validator)
+      validator.attributes.map do |attribute|
+        [KeyGenerator.for_db_uniqueness(attribute, Array.wrap(validator.options[:scope])), attribute]
+      end.to_h
+    end
+
+    # @param [DatabaseValidations::DbUniquenessValidator]
+    #
+    # @return [Hash]
+    def attribute_by_indexes_keys(validator) # rubocop:disable Metrics/AbcSize
+      adapter = Adapters::BaseAdapter.new(validator.klass)
+
+      if validator.index_name
+        [[KeyGenerator.for_unique_index(validator.index_name), validator.attributes[0]]].to_h
+      else
+        validator.attributes.map do |attribute|
+          columns = KeyGenerator.unify_columns(attribute, validator.options[:scope])
+          index = adapter.find_index(columns, validator.where)
+          [KeyGenerator.for_unique_index(index.name), attribute]
+        end.to_h
+      end
+    end
+
+    # @param [DatabaseValidations::DbUniquenessValidator]
+    #
+    # @return [Hash]
+    def attribute_by_key(validator)
+      attribute_by_columns_keys(validator).merge(attribute_by_indexes_keys(validator))
+    end
+  end
+end

data/lib/database_validations/lib/validations.rb

@@ -0,0 +1,31 @@
+module DatabaseValidations
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method :validate, :valid?
+    end
+
+    attr_accessor :_database_validations_fallback
+
+    def valid?(context = nil)
+      self._database_validations_fallback = true
+      super(context)
+    end
+
+    def create_or_update(*args, &block)
+      self._database_validations_fallback = false
+      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
+    rescue ActiveRecord::InvalidForeignKey, ActiveRecord::RecordNotUnique => e
+      raise e unless Rescuer.handled?(self, e)
+
+      raise ActiveRecord::RecordInvalid, self
+    end
+
+    private
+
+    def perform_validations(options = {})
+      options[:validate] == false || valid_without_database_validations?(options[:context])
+    end
+  end
+end

data/lib/database_validations/lib/validators/db_presence_validator.rb

@@ -0,0 +1,63 @@
+module DatabaseValidations
+  class DbPresenceValidator < ActiveRecord::Validations::PresenceValidator
+    REFLECTION_MESSAGE = ActiveRecord::VERSION::MAJOR < 5 ? :blank : :required
+
+    attr_reader :klass
+
+    # Used to make 3rd party libraries work correctly
+    #
+    # @return [Symbol]
+    def self.kind
+      :presence
+    end
+
+    # @param [Hash] options
+    def initialize(options)
+      @klass = options[:class]
+
+      super
+
+      Injector.inject(klass)
+      Checkers::DbPresenceValidator.validate!(self)
+    end
+
+    # TODO: add support of optional db_belongs_to
+    def validate(record)
+      if record._database_validations_fallback
+        super
+      else
+        attributes.each do |attribute|
+          reflection = record.class._reflect_on_association(attribute)
+
+          next if reflection && record.public_send(reflection.foreign_key).present?
+
+          validate_each(record, attribute, record.public_send(attribute))
+        end
+      end
+    end
+
+    def apply_error(instance, attribute)
+      # Helps to avoid querying the database when attribute is association
+      instance.send("#{attribute}=", nil)
+      instance.errors.add(attribute, :blank, message: REFLECTION_MESSAGE)
+    end
+  end
+
+  module ClassMethods
+    def validates_db_presence_of(*attr_names)
+      validates_with(DatabaseValidations::DbPresenceValidator, _merge_attributes(attr_names))
+    end
+
+    def db_belongs_to(name, scope = nil, **options)
+      if ActiveRecord::VERSION::MAJOR < 5
+        options[:required] = false
+      else
+        options[:optional] = true
+      end
+
+      belongs_to(name, scope, options)
+
+      validates_with DatabaseValidations::DbPresenceValidator, _merge_attributes([name, message: DatabaseValidations::DbPresenceValidator::REFLECTION_MESSAGE]) # rubocop:disable Metrics/LineLength
+    end
+  end
+end

data/lib/database_validations/lib/validators/db_uniqueness_validator.rb

@@ -0,0 +1,48 @@
+module DatabaseValidations
+  class DbUniquenessValidator < ActiveRecord::Validations::UniquenessValidator
+    attr_reader :index_name, :where, :klass
+
+    # Used to make 3rd party libraries work correctly
+    #
+    # @return [Symbol]
+    def self.kind
+      :uniqueness
+    end
+
+    # @param [Hash] options
+    def initialize(options)
+      options[:allow_nil] = true
+      options[:allow_blank] = false
+
+      if options.key?(:where)
+        condition = options[:where]
+        options[:conditions] = -> { where(condition) }
+      end
+
+      @index_name = options.delete(:index_name) if options.key?(:index_name)
+      @where = options.delete(:where) if options.key?(:where)
+
+      super
+
+      Injector.inject(klass)
+      Checkers::DbUniquenessValidator.validate!(self)
+    end
+
+    def validate(record)
+      super if record._database_validations_fallback
+    end
+
+    def apply_error(instance, attribute)
+      error_options = options.except(:case_sensitive, :scope, :conditions)
+      error_options[:value] = instance.public_send(attribute)
+
+      instance.errors.add(attribute, :taken, error_options)
+    end
+  end
+
+  module ClassMethods
+    def validates_db_uniqueness_of(*attr_names)
+      validates_with(DatabaseValidations::DbUniquenessValidator, _merge_attributes(attr_names))
+    end
+  end
+end

data/lib/database_validations/rspec/uniqueness_validator_matcher.rb

@@ -46,26 +46,28 @@ RSpec::Matchers.define :validate_db_uniqueness_of do |field| # rubocop:disable M
 
     model = object.is_a?(Class) ? object : object.class
 
-    DatabaseValidations::Helpers.each_options_storage(model) do |storage|
-      storage.options.grep(DatabaseValidations::UniquenessOptions).each do |validator|
+    model.validators.grep(DatabaseValidations::DbUniquenessValidator).each do |validator|
+      validator.attributes.each do |attribute|
         @validators << {
-          field: validator.field,
-          scope: validator.scope,
-          where: validator.where_clause,
-          message: validator.message,
+          field: attribute,
+          scope: Array.wrap(validator.options[:scope]),
+          where: validator.where,
+          message: validator.options[:message],
           index_name: validator.index_name,
-          case_sensitive: validator.case_sensitive
+          case_sensitive: validator.options[:case_sensitive]
         }
       end
     end
 
+    case_sensitive_default = ActiveRecord::VERSION::MAJOR >= 6 ? nil : true
+
     @validators.include?(
       field: field,
       scope: Array.wrap(@scope),
       where: @where,
       message: @message,
       index_name: @index_name,
-      case_sensitive: @case_sensitive
+      case_sensitive: @case_sensitive.nil? ? case_sensitive_default : @case_sensitive
     )
   end
 

data/lib/database_validations/version.rb

@@ -1,3 +1,3 @@
 module DatabaseValidations
-  VERSION = '0.8.10'.freeze
+  VERSION = '0.9.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_validations
 version: !ruby/object:Gem::Version
-  version: 0.8.10
+  version: 0.9.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-21 00:00:00.000000000 Z
+date: 2019-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +156,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
 description: |-
   ActiveRecord provides validations on app level but it won't guarantee the
   consistent. In some cases, like `validates_uniqueness_of` it executes
@@ -169,16 +183,19 @@ files:
 - lib/database_validations/lib/adapters/mysql_adapter.rb
 - lib/database_validations/lib/adapters/postgresql_adapter.rb
 - lib/database_validations/lib/adapters/sqlite_adapter.rb
-- lib/database_validations/lib/db_belongs_to/belongs_to_handlers.rb
-- lib/database_validations/lib/db_belongs_to/belongs_to_options.rb
-- lib/database_validations/lib/db_belongs_to/db_presence_validator.rb
+- lib/database_validations/lib/attribute_validator.rb
+- lib/database_validations/lib/checkers/db_presence_validator.rb
+- lib/database_validations/lib/checkers/db_uniqueness_validator.rb
 - lib/database_validations/lib/errors.rb
-- lib/database_validations/lib/helpers.rb
-- lib/database_validations/lib/options_storage.rb
+- lib/database_validations/lib/injector.rb
+- lib/database_validations/lib/key_generator.rb
+- lib/database_validations/lib/presence_key_extractor.rb
 - lib/database_validations/lib/rescuer.rb
-- lib/database_validations/lib/validates_db_uniqueness_of/db_uniqueness_validator.rb
-- lib/database_validations/lib/validates_db_uniqueness_of/uniqueness_handlers.rb
-- lib/database_validations/lib/validates_db_uniqueness_of/uniqueness_options.rb
+- lib/database_validations/lib/storage.rb
+- lib/database_validations/lib/uniqueness_key_extractor.rb
+- lib/database_validations/lib/validations.rb
+- lib/database_validations/lib/validators/db_presence_validator.rb
+- lib/database_validations/lib/validators/db_uniqueness_validator.rb
 - lib/database_validations/rails/railtie.rb
 - lib/database_validations/rspec/matchers.rb
 - lib/database_validations/rspec/uniqueness_validator_matcher.rb
@@ -207,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: Provide compatibility between database constraints and ActiveRecord validations

data/lib/database_validations/lib/db_belongs_to/belongs_to_handlers.rb

@@ -1,30 +0,0 @@
-module DatabaseValidations
-  module ClassMethods
-    # rubocop: disable Metrics/AbcSize
-    def db_belongs_to(name, scope = nil, **options)
-      Helpers.cache_valid_method!(self)
-
-      @database_validations_storage ||= DatabaseValidations::OptionsStorage.new(self)
-
-      belongs_to_options =
-        if ActiveRecord::VERSION::MAJOR < 5
-          options.delete(:optional)
-          options.merge(required: false)
-        else
-          options.merge(optional: true)
-        end
-
-      belongs_to(name, scope, belongs_to_options)
-
-      foreign_key = reflections[name.to_s].foreign_key
-
-      @database_validations_storage.push_belongs_to(foreign_key, name)
-
-      validates_with DatabaseValidations::DBPresenceValidator,
-                     DatabaseValidations::BelongsToOptions.validator_options(name, foreign_key)
-
-      include(DatabaseValidations::Rescuer)
-    end
-  end
-  # rubocop: enable Metrics/AbcSize
-end

data/lib/database_validations/lib/db_belongs_to/belongs_to_options.rb

@@ -1,46 +0,0 @@
-module DatabaseValidations
-  class BelongsToOptions
-    VALIDATOR_MESSAGE =
-      if ActiveRecord::VERSION::MAJOR < 5
-        :blank
-      else
-        :required
-      end
-
-    def self.validator_options(association, foreign_key)
-      { attributes: association, foreign_key: foreign_key, message: VALIDATOR_MESSAGE }
-    end
-
-    attr_reader :column, :adapter, :relation
-
-    def initialize(column, relation, adapter)
-      @column = column
-      @relation = relation
-      @adapter = adapter
-
-      raise_if_unsupported_database!
-      raise_if_foreign_key_missed! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
-    end
-
-    # @return [String]
-    def key
-      @key ||= Helpers.generate_key_for_belongs_to(column)
-    end
-
-    def handle_foreign_key_error(instance)
-      # Hack to not query the database because we know the result already
-      instance.send("#{relation}=", nil)
-      instance.errors.add(relation, :blank, message: VALIDATOR_MESSAGE)
-    end
-
-    private
-
-    def raise_if_foreign_key_missed!
-      raise Errors::ForeignKeyNotFound.new(column, adapter.foreign_keys) unless adapter.find_foreign_key_by_column(column)
-    end
-
-    def raise_if_unsupported_database!
-      raise Errors::UnsupportedDatabase.new(:db_belongs_to, adapter.adapter_name) if adapter.adapter_name == :sqlite3
-    end
-  end
-end

data/lib/database_validations/lib/db_belongs_to/db_presence_validator.rb

@@ -1,30 +0,0 @@
-module DatabaseValidations
-  class DBPresenceValidator < ActiveRecord::Validations::PresenceValidator
-    # This is a hack to simulate presence validator
-    # It's used for cases when some 3rd parties are relies on the validators
-    # For example, +required+ option from simple_form checks the validator
-    def self.kind
-      :presence
-    end
-
-    attr_reader :foreign_key, :association
-
-    def initialize(options)
-      super(options)
-
-      @association = attributes.first
-      @foreign_key = options[:foreign_key]
-    end
-
-    # The else statement required only for optional: false
-    def validate(record)
-      if record._database_validations_fallback
-        super
-      else
-        return unless record.public_send(foreign_key).blank? && record.public_send(association).blank?
-
-        record.errors.add(association, :blank, message: BelongsToOptions::VALIDATOR_MESSAGE)
-      end
-    end
-  end
-end

data/lib/database_validations/lib/helpers.rb

@@ -1,79 +0,0 @@
-module DatabaseValidations
-  module Helpers
-    module_function
-
-    def cache_valid_method!(klass)
-      return if klass.method_defined?(:valid_without_database_validations?)
-
-      klass.__send__(:alias_method, :valid_without_database_validations?, :valid?)
-    end
-
-    def handle_error!(instance, error)
-      case error
-      when ActiveRecord::RecordNotUnique
-        handle_unique_error!(instance, error)
-      when ActiveRecord::InvalidForeignKey
-        handle_foreign_key_error!(instance, error)
-      else false
-      end
-    end
-
-    def handle_unique_error!(instance, error)
-      adapter = Adapters.factory(instance.class)
-
-      keys = [
-        generate_key_for_uniqueness_index(adapter.unique_index_name(error.message)),
-        generate_key_for_uniqueness(adapter.unique_error_columns(error.message))
-      ]
-
-      each_options_storage(instance.class) do |storage|
-        keys.each { |key| return storage[key].handle_unique_error(instance) if storage[key] }
-      end
-
-      false
-    end
-
-    def handle_foreign_key_error!(instance, error)
-      adapter = Adapters.factory(instance.class)
-      column_key = generate_key_for_belongs_to(adapter.foreign_key_error_column(error.message))
-
-      each_options_storage(instance.class) do |storage|
-        return storage[column_key].handle_foreign_key_error(instance) if storage[column_key]
-      end
-
-      false
-    end
-
-    def each_options_storage(klass)
-      while klass.respond_to?(:validates_db_uniqueness_of)
-        storage = storage_of(klass)
-        yield(storage) if storage
-        klass = klass.superclass
-      end
-    end
-
-    def storage_of(klass)
-      klass.instance_variable_get(:'@database_validations_storage')
-    end
-
-    def unify_columns(*args)
-      args.flatten.compact.map(&:to_s).sort
-    end
-
-    def generate_key_for_uniqueness_index(index_name)
-      generate_key(:uniqueness_index, index_name)
-    end
-
-    def generate_key_for_uniqueness(*columns)
-      generate_key(:uniqueness, columns)
-    end
-
-    def generate_key_for_belongs_to(column)
-      generate_key(:belongs_to, column)
-    end
-
-    def generate_key(type, *args)
-      [type, *unify_columns(args)].join('__')
-    end
-  end
-end

data/lib/database_validations/lib/options_storage.rb

@@ -1,31 +0,0 @@
-module DatabaseValidations
-  class OptionsStorage
-    def initialize(klass)
-      @adapter = Adapters.factory(klass).new(klass)
-      @storage = {}
-    end
-
-    def push_uniqueness(field, options)
-      uniqueness_options = UniquenessOptions.new(field, options, adapter)
-      storage[uniqueness_options.index_key] = uniqueness_options
-      storage[uniqueness_options.column_key] = uniqueness_options
-    end
-
-    def push_belongs_to(field, relation)
-      belongs_to_options = BelongsToOptions.new(field, relation, adapter)
-      storage[belongs_to_options.key] = belongs_to_options
-    end
-
-    def [](key)
-      storage[key]
-    end
-
-    def options
-      storage.values
-    end
-
-    private
-
-    attr_reader :storage, :adapter
-  end
-end

data/lib/database_validations/lib/validates_db_uniqueness_of/db_uniqueness_validator.rb

@@ -1,14 +0,0 @@
-module DatabaseValidations
-  class DBUniquenessValidator < ActiveRecord::Validations::UniquenessValidator
-    # This is a hack to simulate presence validator
-    # It's used for cases when some 3rd parties are relies on the validators
-    # For example, +required+ option from simple_form checks the validator
-    def self.kind
-      :uniqueness
-    end
-
-    def validate(record)
-      super if record._database_validations_fallback
-    end
-  end
-end

data/lib/database_validations/lib/validates_db_uniqueness_of/uniqueness_handlers.rb

@@ -1,20 +0,0 @@
-module DatabaseValidations
-  module ClassMethods
-    def validates_db_uniqueness_of(*attributes)
-      Helpers.cache_valid_method!(self)
-
-      @database_validations_storage ||= DatabaseValidations::OptionsStorage.new(self)
-
-      options = attributes.extract_options!
-
-      attributes.each do |attribute|
-        @database_validations_storage.push_uniqueness(attribute, options.merge(attributes: attribute))
-      end
-
-      validates_with DatabaseValidations::DBUniquenessValidator,
-                     DatabaseValidations::UniquenessOptions.validator_options(attributes, options)
-
-      include(DatabaseValidations::Rescuer)
-    end
-  end
-end

data/lib/database_validations/lib/validates_db_uniqueness_of/uniqueness_options.rb

@@ -1,108 +0,0 @@
-module DatabaseValidations
-  class UniquenessOptions
-    CUSTOM_OPTIONS = %i[where index_name].freeze
-    DEFAULT_OPTIONS = { allow_nil: true, case_sensitive: true, allow_blank: false }.freeze
-
-    def self.validator_options(attributes, options)
-      DEFAULT_OPTIONS
-        .merge(attributes: attributes)
-        .merge(options)
-        .except(*CUSTOM_OPTIONS)
-        .tap { |opts| opts[:conditions] = -> { where(options[:where]) } if options[:where] }
-    end
-
-    attr_reader :field, :calculated_index_name
-
-    def initialize(field, options, adapter)
-      @field = field
-      @options = options
-      @adapter = adapter
-
-      raise_if_unsupported_options!
-
-      return if ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
-
-      index = responsible_index
-      raise_if_index_missed!(index)
-
-      @calculated_index_name = index.name
-    end
-
-    def handle_unique_error(instance)
-      error_options = options.except(:case_sensitive, :scope, :conditions, :attributes, *CUSTOM_OPTIONS)
-      error_options[:value] = instance.public_send(options[:attributes])
-
-      instance.errors.add(options[:attributes], :taken, error_options)
-    end
-
-    # @return [String]
-    def index_key
-      @index_key ||= Helpers.generate_key_for_uniqueness_index(index_name || calculated_index_name)
-    end
-
-    # @return [String]
-    def column_key
-      @column_key ||= Helpers.generate_key_for_uniqueness(columns)
-    end
-
-    # @return [Array<String>]
-    def columns
-      @columns ||= Helpers.unify_columns(field, scope)
-    end
-
-    # @return [String|nil]
-    def where_clause
-      @where_clause ||= options[:where]
-    end
-
-    # @return [String|nil]
-    def message
-      @message ||= options[:message]
-    end
-
-    # @return [Array<String|Symbol>]
-    def scope
-      @scope ||= Array.wrap(options[:scope])
-    end
-
-    # @return [String|Symbol|nil]
-    def index_name
-      @index_name ||= options[:index_name]
-    end
-
-    # @return [Boolean|nil]
-    def case_sensitive
-      @case_sensitive ||= options[:case_sensitive]
-    end
-
-    private
-
-    attr_reader :adapter, :options
-
-    def raise_if_unsupported_options!
-      options.except(:attributes).each_key do |option|
-        unless adapter.support_option?(option)
-          raise Errors::OptionIsNotSupported.new(option, adapter.adapter_name, adapter.supported_options)
-        end
-      end
-    end
-
-    def responsible_index
-      index_name ? adapter.find_index_by_name(index_name.to_s) : adapter.find_index(columns, where_clause)
-    end
-
-    def index_columns_size(columns)
-      columns.is_a?(Array) ? columns.size : (columns.count(',') + 1)
-    end
-
-    def check_index_options?(index)
-      (columns.size == index_columns_size(index.columns)) && (where_clause.nil? == index.where.nil?)
-    end
-
-    def raise_if_index_missed!(index)
-      return if index && check_index_options?(index)
-
-      raise Errors::IndexNotFound.new(columns, where_clause, index_name, adapter.indexes, adapter.table_name)
-    end
-  end
-end