database_validations 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2236241fbd9c25b9cbe9ffa63f5634659c6ad0ded206324cc7021765049ae116
-  data.tar.gz: ec3e6c0ec0ea21a00455a2035452030977994e99bdb4b4ff45b8405d57e5f0d4
+  metadata.gz: 047eabab521a0b04f0385213e7b20a34cb192576935d3e9c2f70aeab28df6ca0
+  data.tar.gz: 61fe8cac30624557d22ff059b2738ccdddbf0bbaa99eb9ac67a74f943fe39abf
 SHA512:
-  metadata.gz: f5691f17f29a775e910150be7415c77a02eb0436e428bf14efa60365f0840574066307b02d0b71de00431dff71f24215e366a68d44f1cf34528efb3570a584ec
-  data.tar.gz: 613e741dc4f48e245f3d6abc9af136fad6ae28d974583e2713ce9af4955d68c97d73fb371444e8fc519bfa428758221680dffc77b48e91a1d9b62103a2291d5a
+  metadata.gz: c99d04c4d975a9f50781422c409fa2e08fe3cc0fbc2ec8bdc015ab766b8c7e45ed646de43cf30c3c23512cc01877462cd16896034b03e390c3fb7309242c0fc0
+  data.tar.gz: '098fa9d49805b3379fa0fa5b95d3c93771be64b709c7cda5c42aecdf2fa33945bf59d3076a7035f548d1dd0de362d9684053330db5118635a1fef60bc1124f57'

data/lib/database_validations/rspec/uniqueness_validator_matcher.rb

@@ -46,7 +46,7 @@ RSpec::Matchers.define :validate_db_uniqueness_of do |field|
 
     model = object.is_a?(Class) ? object : object.class
 
-    DatabaseValidations::Helpers.each_validator(model) do |validator|
+    DatabaseValidations::Helpers.each_uniqueness_validator(model) do |validator|
       @validators << {
         field:          validator.field,
         scope:          validator.scope,

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

@@ -23,6 +23,14 @@ module DatabaseValidations
         model.connection.indexes(model.table_name).select(&:unique)
       end
 
+      def foreign_keys
+        model.connection.foreign_keys(model.table_name)
+      end
+
+      def find_foreign_key_by_column(column)
+        model.connection.foreign_key_exists?(model.table_name, column: column)
+      end
+
       # @return [Symbol]
       def adapter_name
         self.class::ADAPTER

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

@@ -8,9 +8,13 @@ module DatabaseValidations
         error_message[/key '([^']+)'/, 1]
       end
 
-      def error_columns(error_message)
+      def unique_error_columns(error_message)
         find_index_by_name(index_name(error_message)).columns
       end
+
+      def foreign_key_error_column(error_message)
+        error_message[/FOREIGN KEY \(`([^`]+)`\)/, 1]
+      end
     end
   end
 end

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

@@ -8,9 +8,13 @@ module DatabaseValidations
         error_message[/unique constraint "([^"]+)"/, 1]
       end
 
-      def error_columns(error_message)
+      def unique_error_columns(error_message)
         find_index_by_name(index_name(error_message)).columns
       end
+
+      def foreign_key_error_column(error_message)
+        error_message[/Key \(([^)]+)\)/, 1]
+      end
     end
   end
 end

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

@@ -7,9 +7,17 @@ module DatabaseValidations
       def index_name(_error_message)
       end
 
-      def error_columns(error_message)
+      def find_foreign_key_by_column(column)
+        foreign_keys.find { |foreign_key| foreign_key.column.to_s == column.to_s }
+      end
+
+      def unique_error_columns(error_message)
         error_message.scan(/#{model.table_name}\.([^,:]+)/).flatten
       end
+
+      def foreign_key_error_column(error_message)
+        error_message[/\("([^"]+)"\) VALUES/, 1]
+      end
     end
   end
 end

data/lib/database_validations/validations/belongs_to_handlers.rb

@@ -0,0 +1,58 @@
+module DatabaseValidations
+  module BelongsToHandlers
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method :validate, :valid?
+    end
+
+    def valid?(context = nil)
+      output = super(context)
+
+      Helpers.each_belongs_to_presence_validator(self.class) do |validator|
+        validates_with(ActiveRecord::Validations::PresenceValidator, validator.validates_presence_options)
+      end
+
+      errors.empty? && output
+    end
+
+    def save(opts = {})
+      return false unless Helpers.check_foreign_key_missing(self)
+
+      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
+    rescue ActiveRecord::InvalidForeignKey => e
+      Helpers.handle_foreign_key_error!(self, e)
+      false
+    end
+
+    def save!(opts = {})
+      raise ActiveRecord::RecordInvalid, self unless Helpers.check_foreign_key_missing(self)
+
+      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
+    rescue ActiveRecord::InvalidForeignKey => e
+      Helpers.handle_foreign_key_error!(self, e)
+      raise ActiveRecord::RecordInvalid, self
+    end
+
+    private
+
+    def perform_validations(options = {})
+      options[:validate] == false || valid_without_database_validations(options[:context])
+    end
+  end
+
+  module ClassMethods
+    def db_belongs_to(name, scope = nil, **options)
+      include(DatabaseValidations::ValidWithoutDatabaseValidations)
+      @database_validations_opts ||= DatabaseValidations::OptionsStorage.new(self)
+
+      belongs_to(name, scope, options.merge(optional: true))
+
+      foreign_key = reflections[name.to_s].foreign_key
+
+      @database_validations_opts.push_belongs_to(foreign_key, name)
+
+      include(DatabaseValidations::BelongsToHandlers)
+    end
+  end
+end

data/lib/database_validations/validations/belongs_to_options.rb

@@ -0,0 +1,43 @@
+module DatabaseValidations
+  class BelongsToOptions
+    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
+      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: :required)
+    end
+
+    def validates_presence_options
+      {attributes: relation, message: :required}
+    end
+
+    private
+
+    def raise_if_foreign_key_missed!
+      unless adapter.find_foreign_key_by_column(column)
+        raise Errors::ForeignKeyNotFound.new(column, adapter.foreign_keys)
+      end
+    end
+
+    def raise_if_unsupported_database!
+      if adapter.adapter_name == :sqlite3
+        raise Errors::UnsupportedDatabase.new(:db_belongs_to, adapter.adapter_name)
+      end
+    end
+  end
+end

data/lib/database_validations/validations/errors.rb

@@ -1,6 +1,10 @@
 module DatabaseValidations
   module Errors
-    class Base < StandardError; end
+    class Base < StandardError
+      def env_message
+        "Use ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']=true in case you want to skip the check. For example, when you run migrations."
+      end
+    end
 
     class IndexNotFound < Base
       attr_reader :columns, :where_clause, :index_name, :available_indexes
@@ -19,7 +23,7 @@ module DatabaseValidations
                  "Available indexes are: [#{self.available_indexes.map { |ind| columns_and_where_text(ind.columns, ind.where) }.join(', ')}]. "
                end
 
-        super text + "Use ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']=true in case you want to skip the check. For example, when you run migrations."
+        super text + env_message
       end
 
       def columns_and_where_text(columns, where)
@@ -46,5 +50,26 @@ module DatabaseValidations
         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
+
+      def initialize(column, foreign_keys)
+        @column = column
+        @foreign_keys = foreign_keys
+
+        super "No foreign key found with column: \"#{column}\". Founded foreign keys are: #{foreign_keys}. " + env_message
+      end
+    end
+
+    class UnsupportedDatabase < Base
+      attr_reader :database, :method
+
+      def initialize(method, database)
+        @database = database
+        @method = method
+        super "Database #{database} doesn't support #{method}"
+      end
+    end
   end
 end

data/lib/database_validations/validations/helpers.rb

@@ -4,8 +4,8 @@ module DatabaseValidations
 
     def handle_unique_error!(instance, error)
       adapter = Adapters.factory(instance.class)
-      index_key = adapter.index_name(error.message)
-      column_key = generate_key(adapter.error_columns(error.message))
+      index_key = generate_key_for_uniqueness_index(adapter.index_name(error.message))
+      column_key = generate_key_for_uniqueness(adapter.unique_error_columns(error.message))
 
       each_options_storage(instance.class) do |storage|
         return storage[index_key].handle_unique_error(instance) if storage[index_key]
@@ -15,17 +15,43 @@ module DatabaseValidations
       raise error
     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
+
+      raise error
+    end
+
+    def check_foreign_key_missing(instance)
+      Helpers.each_belongs_to_presence_validator(instance.class) do |validator|
+        if instance.public_send(validator.column).nil? && instance.public_send(validator.relation).nil?
+          instance.errors.add(validator.relation, :blank, message: :required)
+        end
+      end
+      instance.errors.empty?
+    end
+
     def each_options_storage(klass)
       while klass.respond_to?(:validates_db_uniqueness_of)
-        storage = klass.instance_variable_get(:'@validates_db_uniqueness_opts')
+        storage = klass.instance_variable_get(:'@database_validations_opts')
         yield(storage) if storage
         klass = klass.superclass
       end
     end
 
-    def each_validator(klass)
+    def each_uniqueness_validator(klass)
       each_options_storage(klass) do |storage|
-        storage.each_validator { |validator| yield(validator) }
+        storage.each_uniqueness_validator { |validator| yield(validator) }
+      end
+    end
+
+    def each_belongs_to_presence_validator(klass)
+      each_options_storage(klass) do |storage|
+        storage.each_belongs_to_presence_validator { |validator| yield(validator) }
       end
     end
 
@@ -33,8 +59,20 @@ module DatabaseValidations
       columns.flatten.compact.map(&:to_s).sort
     end
 
-    def generate_key(*columns)
-      unify_columns(columns).join('__')
+    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, *columns)
+      [type, *unify_columns(columns)].join('__')
     end
   end
 end

data/lib/database_validations/validations/options_storage.rb

@@ -0,0 +1,35 @@
+module DatabaseValidations
+  class OptionsStorage
+
+    def initialize(klass)
+      @adapter = Adapters.factory(klass)
+      @storage = {}
+    end
+
+    def push_uniqueness(field, options)
+      uniqueness_options = UniquenessOptions.new(field, options, adapter)
+      storage[uniqueness_options.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 each_uniqueness_validator
+      storage.values.grep(UniquenessOptions).each { |validator| yield(validator) }
+    end
+
+    def each_belongs_to_presence_validator
+      storage.values.grep(BelongsToOptions).each { |validator| yield(validator) }
+    end
+
+    private
+
+    attr_reader :storage, :adapter
+  end
+end

data/lib/database_validations/validations/{uniqueness_validator.rb → uniqueness_handlers.rb}

@@ -3,21 +3,19 @@ module DatabaseValidations
     extend ActiveSupport::Concern
 
     included do
-      alias_method :valid_without_uniqueness?, :valid?
+      alias_method :validate, :valid?
+    end
 
-      def valid?(context = nil)
-        output = super(context)
+    def valid?(context = nil)
+      output = super(context)
 
-        Helpers.each_validator(self.class) do |validator|
-          if validator.if_and_unless_pass?(self)
-            validates_with(ActiveRecord::Validations::UniquenessValidator, validator.validates_uniqueness_options)
-          end
+      Helpers.each_uniqueness_validator(self.class) do |validator|
+        if validator.if_and_unless_pass?(self)
+          validates_with(ActiveRecord::Validations::UniquenessValidator, validator.validates_uniqueness_options)
         end
-
-        errors.empty? && output
       end
 
-      alias_method :validate, :valid?
+      errors.empty? && output
     end
 
     def save(options = {})
@@ -37,18 +35,19 @@ module DatabaseValidations
     private
 
     def perform_validations(options = {})
-      options[:validate] == false || valid_without_uniqueness?(options[:context])
+      options[:validate] == false || valid_without_database_validations(options[:context])
     end
   end
 
   module ClassMethods
     def validates_db_uniqueness_of(*attributes)
-      @validates_db_uniqueness_opts ||= DatabaseValidations::UniquenessOptionsStorage.new(self)
+      include(DatabaseValidations::ValidWithoutDatabaseValidations)
+      @database_validations_opts ||= DatabaseValidations::OptionsStorage.new(self)
 
       options = attributes.extract_options!
 
       attributes.each do |attribute|
-        @validates_db_uniqueness_opts.push(attribute, options.merge(attributes: attribute))
+        @database_validations_opts.push_uniqueness(attribute, options.merge(attributes: attribute))
       end
 
       include(DatabaseValidations::UniquenessHandlers)

data/lib/database_validations/validations/uniqueness_options.rb

@@ -39,7 +39,7 @@ module DatabaseValidations
 
     # @return [String]
     def key
-      @key ||= index_name ? index_name.to_s : Helpers.generate_key(columns)
+      @key ||= index_name ? Helpers.generate_key_for_uniqueness_index(index_name) : Helpers.generate_key_for_uniqueness(columns)
     end
 
     # @return [Array<String>]

data/lib/database_validations/validations/valid_without_database_validations.rb

@@ -0,0 +1,9 @@
+module DatabaseValidations
+  module ValidWithoutDatabaseValidations
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method :valid_without_database_validations, :valid?
+    end
+  end
+end

data/lib/database_validations/version.rb

@@ -1,3 +1,3 @@
 module DatabaseValidations
-  VERSION = '0.7.3'
+  VERSION = '0.8.0'
 end

data/lib/database_validations.rb

@@ -4,9 +4,14 @@ require 'database_validations/version'
 
 require 'database_validations/rails/railtie' if defined?(Rails)
 
-require 'database_validations/validations/uniqueness_validator'
+require 'database_validations/validations/uniqueness_handlers'
 require 'database_validations/validations/uniqueness_options'
-require 'database_validations/validations/uniqueness_options_storage'
+
+require 'database_validations/validations/belongs_to_handlers'
+require 'database_validations/validations/belongs_to_options'
+
+require 'database_validations/validations/valid_without_database_validations'
+require 'database_validations/validations/options_storage'
 require 'database_validations/validations/errors'
 require 'database_validations/validations/helpers'
 require 'database_validations/validations/adapters'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_validations
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-18 00:00:00.000000000 Z
+date: 2018-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -155,8 +155,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE.txt
-- README.md
 - lib/database_validations.rb
 - lib/database_validations/rails/railtie.rb
 - lib/database_validations/rspec/matchers.rb
@@ -167,11 +165,14 @@ files:
 - lib/database_validations/validations/adapters/mysql_adapter.rb
 - lib/database_validations/validations/adapters/postgresql_adapter.rb
 - lib/database_validations/validations/adapters/sqlite_adapter.rb
+- lib/database_validations/validations/belongs_to_handlers.rb
+- lib/database_validations/validations/belongs_to_options.rb
 - lib/database_validations/validations/errors.rb
 - lib/database_validations/validations/helpers.rb
+- lib/database_validations/validations/options_storage.rb
+- lib/database_validations/validations/uniqueness_handlers.rb
 - lib/database_validations/validations/uniqueness_options.rb
-- lib/database_validations/validations/uniqueness_options_storage.rb
-- lib/database_validations/validations/uniqueness_validator.rb
+- lib/database_validations/validations/valid_without_database_validations.rb
 - lib/database_validations/version.rb
 homepage: https://github.com/toptal/database_validations
 licenses:
@@ -193,7 +194,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Provide compatibility between database constraints and ActiveRecord validations

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2018 Toptal
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/README.md

@@ -1,212 +0,0 @@
-# DatabaseValidations
-
-[![Build Status](https://travis-ci.org/toptal/database_validations.svg?branch=master)](https://travis-ci.org/toptal/database_validations)
-[![Gem Version](https://badge.fury.io/rb/database_validations.svg)](https://badge.fury.io/rb/database_validations)
-
-ActiveRecord provides validations on app level but it won't guarantee the 
-consistent. In some cases, like `validates_uniqueness_of` it executes 
-additional SQL query to the database and that is not very efficient. 
-
-The main goal of the gem is to provide compatibility between database constraints 
-and ActiveRecord validations with better performance and consistency.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'database_validations'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install database_validations
-
-## validates_db_uniqueness_of
-
-Supported databases: `postgresql`, `mysql` and `sqlite`.
-
-### Pros and Cons
-
-Advantages: 
-- Provides true uniqueness on the database level because it handles race conditions cases properly.
-- Check the existence of correct unique index at the boot time. Use `ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK'] = 'true'` 
-if you want to skip it in some cases.
-- It's faster. See [Benchmark](https://github.com/toptal/database_validations#benchmark-code) section for details.
-
-Disadvantages: 
-- Cannot handle multiple validations at once because database raises only one error for all indexes per query.
-    ```ruby
-    class User < ActiveRecord::Base
-      validates_db_uniqueness_of :email, :name
-    end
-  
-    original = User.create(name: 'name', email: 'email@mail.com')
-    dupe = User.create(name: 'name', email: 'email@mail.com')
-    # => false
-    dupe.errors.messages
-    # => {:name=>["has already been taken"]} 
-    ```
-
-### How it works?
-
-We override `save` and `save!` methods where we rescue `ActiveRecord::RecordNotUnique` and add proper errors
-for compatibility.
-
-For `valid?` we use implementation from `validates_uniqueness_of` where we query the database.
-
-### Usage
-
-```ruby
-class User < ActiveRecord::Base
-  validates_db_uniqueness_of :email
-end
-
-original = User.create(email: 'email@mail.com')
-dupe = User.create(email: 'email@mail.com')
-# => false
-dupe.errors.messages
-# => {:email=>["has already been taken"]}
-User.create!(email: 'email@mail.com')
-# => ActiveRecord::RecordInvalid Validation failed: email has already been taken
-```
-
-### Configuration options
-
-We want to provide full compatibility with existing `validates_uniqueness_of` validator. 
-
-| Option name    | PostgreSQL | MySQL | SQLite |
-| -------------- | :--------: | :---: | :----: |
-| scope          | +          | +     | +      |
-| message        | +          | +     | +      |
-| if             | +          | +     | +      |
-| unless         | +          | +     | +      |
-| index_name     | +          | +     | -      |
-| where          | +          | -     | -      |
-| case_sensitive | +          | -     | -      |
-| allow_nil      | -          | -     | -      | 
-| allow_blank    | -          | -     | -      |
-
-**Keep in mind**: `if`, `unless` and `case_sensitive` options are used only for `valid?` method. 
-
-```ruby
-class User < ActiveRecord::Base
-  validates_db_uniqueness_of :email, if: -> { email && email_changed? }
-end 
-
-user = User.create(email: 'email@mail.com', field: 'field')
-user.field = 'another'
-
-user.valid? # Will not query the database
-```
-
-**Backward compatibility**: Even when we don't natively support `case_sensitive`, `allow_nil` and `allow_blank` options now, the following:
-
-```ruby
-validates_db_uniqueness_of :email
-```
-
-Is the same by default as the following 
-
-```ruby
-validates_uniqueness_of :email, allow_nil: true, allow_blank: false, case_sensitive: true
-``` 
-
-Complete `case_sensitive` replacement example (for `PostgreSQL` only):
-
-```ruby
-validates :slug, uniqueness: { case_sensitive: false, scope: :field }
-```
-
-Should be replaced by:
-
-```ruby
-validates_db_uniqueness_of :slug, index_name: :unique_index_with_field_lower_on_slug, case_sensitive: false
-```
-
-Options descriptions: 
-- `scope`: One or more columns by which to limit the scope of the uniqueness constraint.
-- `message`: Specifies a custom error message (default is: "has already been taken").
-- `if`: Specifies a method or proc to call to determine if the validation should occur 
-(e.g. `if: :allow_validation`, or `if: Proc.new { |user| user.signup_step > 2 }`). The method or
-proc should return or evaluate to a `true` or `false` value.
-- `unless`: Specifies a method or proc to call to determine if the validation should not 
-occur (e.g. `unless: :skip_validation`, or `unless: Proc.new { |user| user.signup_step <= 2 }`). 
-The method or proc should return or evaluate to a `true` or `false` value.
-- `where`: Specify the conditions to be included as a `WHERE` SQL fragment to 
-limit the uniqueness constraint lookup (e.g. `where: "(status = 'active')"`).
-For backward compatibility, this will be converted automatically 
-to `conditions: -> { where("(status = 'active')") }` for `valid?` method.
-- `case_sensitive`: Looks for an exact match. Ignored by non-text columns (`true` by default).
-- `allow_nil`: If set to `true`, skips this validation if the attribute is `nil` (default is `false`).
-- `allow_blank`: If set to `true`, skips this validation if the attribute is blank (default is `false`).
-- `index_name`: Allows to make explicit connection between validator and index. Used when gem can't automatically find index. 
-
-### Benchmark ([code](https://github.com/toptal/database_validations/blob/master/benchmarks/uniqueness_validator_benchmark.rb))
-
-| Case                             | Validator                  | SQLite                                     | PostgreSQL                                 | MySQL                                      |
-| -------------------------------- | -------------------------- | ------------------------------------------ | ------------------------------------------ | ------------------------------------------ |
-| Save duplicate item only         | validates_db_uniqueness_of | 1.404k (±14.7%) i/s - 6.912k in 5.043409s  | 508.889 (± 2.8%) i/s - 2.550k in 5.015044s | 649.356 (±11.5%) i/s - 3.283k in 5.153444s |
-|                                  | validates_uniqueness_of    | 1.505k (±14.6%) i/s - 7.448k in 5.075696s  | 637.017 (±14.1%) i/s - 3.128k in 5.043434s | 473.561 (± 9.7%) i/s - 2.352k in 5.021151s |
-| Save unique item only            | validates_db_uniqueness_of | 3.241k (±18.3%) i/s - 15.375k in 5.014244s | 1.345k  (± 5.5%) i/s - 6.834k in 5.096706s | 1.439k  (±12.9%) i/s - 7.100k in 5.033603s |
-|                                  | validates_uniqueness_of    | 2.002k (±10.9%) i/s - 9.900k in 5.018449s  | 667.100 (± 4.8%) i/s - 3.350k in 5.034451s | 606.334 (± 4.9%) i/s - 3.068k in 5.072587s |
-| Each hundredth item is duplicate | validates_db_uniqueness_of | 3.534k (± 5.6%) i/s - 17.748k in 5.039277s | 1.351k  (± 6.5%) i/s - 6.750k in 5.017280s | 1.436k  (±11.6%) i/s - 7.154k in 5.062644s |
-|                                  | validates_uniqueness_of    | 2.121k (± 6.8%) i/s - 10.653k in 5.049739s | 658.199 (± 6.1%) i/s - 3.350k in 5.110176s | 596.024 (± 6.7%) i/s - 2.989k in 5.041497s |
-
-## Testing (RSpec)
-
-Add `require database_validations/rspec/matchers'` to your `spec` file.
-
-### validate_db_uniqueness_of
-
-Example: 
-
-```ruby
-class User < ActiveRecord::Base
-  validates_db_uniqueness_of :field, message: 'duplicate', where: '(some_field IS NULL)', scope: :another_field, index_name: :unique_index
-end
-
-describe 'validations' do
-  subject { User }
-  
-  it { is_expected.to validate_db_uniqueness_of(:field).with_message('duplicate').with_where('(some_field IS NULL)').scoped_to(:another_field).with_index(:unique_index) }
-end
-```
-
-## Development
-
-You need to have installed and running `postgresql` and `mysql`. 
-And for each adapter manually create a database called `database_validations_test`. 
-
-After checking out the repo, run `bin/setup` to install dependencies.
-
-Then, run `rake spec` to run the tests. You can also run `bin/console` for 
-an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. 
-To release a new version, update the version number in `version.rb`, and then 
-run `bundle exec rake release`, which will create a git tag for the version, 
-push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-[Bug reports](https://github.com/toptal/database_validations/issues) and [pull requests](https://github.com/toptal/database_validations/pulls) are welcome on GitHub. 
-This project is intended to be a safe, welcoming space for collaboration, and contributors are expected 
-to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the DatabaseValidations project’s codebases, issue trackers, chat rooms and mailing 
-lists is expected to follow the [code of conduct](https://github.com/toptal/database_validations/blob/master/CODE_OF_CONDUCT.md).
-
-## Authors
-
-- [Evgeniy Demin](https://github.com/djezzzl)

data/lib/database_validations/validations/uniqueness_options_storage.rb

@@ -1,26 +0,0 @@
-module DatabaseValidations
-  class UniquenessOptionsStorage
-
-    def initialize(klass)
-      @adapter = Adapters.factory(klass)
-      @storage = {}
-    end
-
-    def push(field, options)
-      uniqueness_options = UniquenessOptions.new(field, options, adapter)
-      storage[uniqueness_options.key] = uniqueness_options
-    end
-
-    def [](key)
-      storage[key]
-    end
-
-    def each_validator
-      storage.each_value { |validator| yield(validator) }
-    end
-
-    private
-
-    attr_reader :storage, :adapter
-  end
-end