database_validations 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34f55425dd0da6279bd235d760df174ac1f028365f00d88be653b601207b526d
-  data.tar.gz: 8ef9de8f18ba558c5c1cfb9be9af9f0257cd188df35b05545fc479490f799316
+  metadata.gz: 5c0e233ecf1999d511840c65bbce2744faf3af3cfc2a1c64f1bcee504c86129e
+  data.tar.gz: ed0cb02abcb98e1e4e8d6172a3695b953fdcc9f05561dd6c7c63945929705061
 SHA512:
-  metadata.gz: 8ad092489894f94f52ac4ed99b83dedb383bd0643af8f938c8225c3d1f1cf69d625d2b687346492f45980851a93b45489c76043f5c98be836fcc3739d4f4e1aa
-  data.tar.gz: ee668b15d32473eda6b01fc18ab4c9d7336dfd415ee42e33e2e27168f444a3bef7fc4067b6c59793ef5c065cccd5ddca28469439d3c53bb213bc4468e6c42bdb
+  metadata.gz: aa02581639a2a37ae25202d32aee451934d607a96843fe13227096eeda0631ce759e538d14e34c3e523e6302ec91fe88c3a651aabd3cda717ace5fb13f9c824e
+  data.tar.gz: 0f84690c7ce7fdd5a19c62c20ea211b33d8a5039254e3b08a5765eef050d69f426cbfcaa0d1cdaa15f00e07c0ff503d0535ccc194bfd031a90237d18e1df2a35

data/README.md

@@ -1,5 +1,7 @@
 # DatabaseValidations
 
+[![Build Status](https://travis-ci.org/toptal/database_validations.svg?branch=master)](https://travis-ci.org/toptal/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. 
@@ -76,18 +78,19 @@ User.create!(email: 'email@mail.com')
 
 We want to provide full compatibility with existing `validates_uniqueness_of` validator. 
 
-List of supported options from `validates_uniqueness_of` validator: 
+| Option name    | PostgreSQL | MySQL | SQLite |
+| -------------- | :--------: | :---: | :----: |
+| scope          | +          | +     | +      |
+| message        | +          | +     | +      |
+| if             | +          | +     | +      |
+| unless         | +          | +     | +      |
+| index_name     | +          | +     | -      |
+| where          | +          | -     | -      |
+| case_sensitive | -          | -     | -      |
+| allow_nil      | -          | -     | -      | 
+| allow_blank    | -          | -     | -      |
 
-- `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.
-
-**Keep in mind**: Both `if` and `unless` options are used only for `valid?` method and provided only for performance reason. 
+**Keep in mind**: Both `if` and `unless` options are used only for `valid?` method and provided only for performance reason.
 
 ```ruby
 class User < ActiveRecord::Base
@@ -112,20 +115,23 @@ Is the same by default as the following
 validates_uniqueness_of :email, allow_nil: true, allow_blank: false, case_sensitive: true
 ``` 
 
-List of supported options for `PostgreSQL` only:
-
+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.
-
-The list of options to add support:
-
 - `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`).
-
-**Note**: For `PosgreSQL`, it is possible to replace these options with combination of other supported options.
+- `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))
 

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

@@ -8,12 +8,15 @@ module DatabaseValidations
         @model = model
       end
 
+      # @param [String] index_name
       def find_index_by_name(index_name)
         indexes.find { |index| index.name == index_name }
       end
 
+      # @param [Array<String>] columns
+      # @param [String] where
       def find_index(columns, where)
-        indexes.find { |index| index.columns.map(&:to_s).sort == columns && index.where == where }
+        indexes.find { |index| Array.wrap(index.columns).map(&:to_s).sort == columns && index.where == where }
       end
 
       def indexes

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

@@ -1,12 +1,15 @@
 module DatabaseValidations
   module Adapters
     class MysqlAdapter < BaseAdapter
-      SUPPORTED_OPTIONS = %i[scope message if unless].freeze
+      SUPPORTED_OPTIONS = %i[scope message if unless index_name].freeze
       ADAPTER = :mysql2
 
+      def index_name(error_message)
+        error_message[/key '([^']+)'/, 1]
+      end
+
       def error_columns(error_message)
-        index_name = error_message[/key '([^']+)'/, 1]
-        find_index_by_name(index_name).columns
+        find_index_by_name(index_name(error_message)).columns
       end
     end
   end

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

@@ -1,12 +1,15 @@
 module DatabaseValidations
   module Adapters
     class PostgresqlAdapter < BaseAdapter
-      SUPPORTED_OPTIONS = %i[scope message where if unless].freeze
+      SUPPORTED_OPTIONS = %i[scope message where if unless index_name].freeze
       ADAPTER = :postgresql
 
+      def index_name(error_message)
+        error_message[/unique constraint "([^"]+)"/, 1]
+      end
+
       def error_columns(error_message)
-        index_name = error_message[/unique constraint "([^"]+)"/, 1]
-        find_index_by_name(index_name).columns
+        find_index_by_name(index_name(error_message)).columns
       end
     end
   end

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

@@ -4,6 +4,9 @@ module DatabaseValidations
       SUPPORTED_OPTIONS = %i[scope message if unless].freeze
       ADAPTER = :sqlite3
 
+      def index_name(_error_message)
+      end
+
       def error_columns(error_message)
         error_message.scan(/#{model.table_name}\.([^,:]+)/).flatten
       end

data/lib/database_validations/validations/errors.rb

@@ -3,17 +3,23 @@ module DatabaseValidations
     class Base < StandardError; end
 
     class IndexNotFound < Base
-      attr_reader :columns, :where_clause, :available_indexes
+      attr_reader :columns, :where_clause, :index_name, :available_indexes
 
-      def initialize(columns, where_clause, available_indexes)
-        @columns = columns.map(&:to_s)
+      def initialize(columns, where_clause, index_name, available_indexes)
+        @columns = columns
         @where_clause = where_clause
         @available_indexes = available_indexes
+        @index_name = index_name
 
-        super "No unique index found with #{columns_and_where_text(columns, where_clause)}. "\
-              "Available indexes are: [#{self.available_indexes.map { |ind| columns_and_where_text(ind.columns, ind.where) }.join(', ')}]. "\
-              "Use ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']=true in case you want to skip the check. "\
-              "For example, when you run migrations."
+        text = if index_name
+                 "No unique index found with name: \"#{index_name}\". "\
+                 "Available indexes are: #{self.available_indexes.map(&:name)}. "
+               else
+                 "No unique index found with #{columns_and_where_text(columns, where_clause)}. "\
+                 "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."
       end
 
       def columns_and_where_text(columns, where)

data/lib/database_validations/validations/helpers.rb

@@ -3,10 +3,13 @@ module DatabaseValidations
     module_function
 
     def handle_unique_error!(instance, error)
-      key = generate_key(Adapters.factory(instance.class).error_columns(error.message))
+      adapter = Adapters.factory(instance.class)
+      index_key = adapter.index_name(error.message)
+      column_key = generate_key(adapter.error_columns(error.message))
 
       each_options_storage(instance.class) do |storage|
-        return storage[key].handle_unique_error(instance) if storage[key]
+        return storage[index_key].handle_unique_error(instance) if storage[index_key]
+        return storage[column_key].handle_unique_error(instance) if storage[column_key]
       end
 
       raise error

data/lib/database_validations/validations/uniqueness_options.rb

@@ -1,5 +1,7 @@
 module DatabaseValidations
   class UniquenessOptions
+    CUSTOM_OPTIONS = %i[where index_name].freeze
+
     attr_reader :field
 
     def initialize(field, options, adapter)
@@ -12,45 +14,57 @@ module DatabaseValidations
     end
 
     def handle_unique_error(instance)
-      error_options = options.except(:case_sensitive, :scope, :conditions, :attributes, :where)
+      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 [Hash<Symbol, Object>]
     def validates_uniqueness_options
       where_clause_str = where_clause
 
-      options.except(:where)
+      options.except(*CUSTOM_OPTIONS)
         .merge(allow_nil: true, case_sensitive: true, allow_blank: false)
         .tap { |opts| opts[:conditions] = -> { where(where_clause_str) } if where_clause }
     end
 
+    # @return [Boolean]
     def if_and_unless_pass?(instance)
       (options[:if].nil? || condition_passes?(options[:if], instance)) &&
         (options[:unless].nil? || !condition_passes?(options[:unless], instance))
     end
 
+    # @return [String]
     def key
-      @key ||= Helpers.generate_key(columns)
+      @key ||= index_name ? index_name.to_s : Helpers.generate_key(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
+
     private
 
     attr_reader :adapter, :options
@@ -74,8 +88,10 @@ module DatabaseValidations
     end
 
     def raise_if_index_missed!
-      raise Errors::IndexNotFound.new(columns, where_clause, adapter.indexes) unless adapter.find_index(columns, where_clause)
+      unless (index_name && adapter.find_index_by_name(index_name.to_s)) ||
+        (!index_name && adapter.find_index(columns, where_clause))
+        raise Errors::IndexNotFound.new(columns, where_clause, index_name, adapter.indexes)
+      end
     end
   end
 end
-

data/lib/database_validations/version.rb

@@ -1,3 +1,3 @@
 module DatabaseValidations
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_validations
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-26 00:00:00.000000000 Z
+date: 2018-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord