database_validations 0.8.6 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b696cae920dc9834393d2cf25127c7d9c9504750ec32d58f57c2bc873f735709
-  data.tar.gz: d2235fff367e21b9684d245b13773099bc1a1c292b1590a9888be33ae4bd1ad9
+  metadata.gz: 9c5d3a56f3d69b34fdc1da4e3b74b9ff3797d0ca93772df93746e709f9b9fd64
+  data.tar.gz: db772a3a726ccce4ce21bfceb0ddac72da07d9da3650f89d1845e92e580519b2
 SHA512:
-  metadata.gz: 9c5740414831fa3fffcd45d4acbc5771c6b4eb49eb30de1a221ecca7dd801b841a4c55939911fab66a30f5a641a8cef19ecd5a4efb13b2a2dfd2a8f1ae80864a
-  data.tar.gz: d3dd1b8fda9f3c187f0ecf14ecdc24322e76583bb9278cb0e1adb38decbb325be7064d24ec1ccf6cc393c5a2b72a86a7ce4e57b4026260ba0b31f88bb00b2085
+  metadata.gz: da0b57c3e7203be84466c31f72a517852d1b4484a306607bf48e6d6f6d683e43dc1ebdcd678bc258075c5ce1f9c52af756805b749ab5562cc84ac83a6ac48ee4
+  data.tar.gz: 1580a4718c53aa42267a2d7efd04148df0de38ddba3ce7c4c5f6c4c226736e4f568919cbe600b79d269566f081c7c9537b09fca0f5b0d65cdd73378e81b9ae71

data/lib/database_validations/lib/adapters.rb

@@ -9,9 +9,9 @@ module DatabaseValidations
 
     def factory(model)
       case (database = model.connection_config[:adapter].downcase.to_sym)
-      when SqliteAdapter::ADAPTER then SqliteAdapter.new(model)
-      when PostgresqlAdapter::ADAPTER then PostgresqlAdapter.new(model)
-      when MysqlAdapter::ADAPTER then MysqlAdapter.new(model)
+      when SqliteAdapter::ADAPTER then SqliteAdapter
+      when PostgresqlAdapter::ADAPTER then PostgresqlAdapter
+      when MysqlAdapter::ADAPTER then MysqlAdapter
       else
         raise Errors::UnknownDatabase, database
       end

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

@@ -28,7 +28,7 @@ module DatabaseValidations
       end
 
       def find_foreign_key_by_column(column)
-        model.connection.foreign_key_exists?(model.table_name, column: column)
+        foreign_keys.find { |foreign_key| foreign_key.column.to_s == column.to_s }
       end
 
       # @return [Symbol]

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

@@ -4,16 +4,16 @@ module DatabaseValidations
       SUPPORTED_OPTIONS = %i[scope message if unless index_name].freeze
       ADAPTER = :mysql2
 
-      def index_name(error_message)
-        error_message[/key '([^']+)'/, 1]
-      end
+      class << self
+        def unique_index_name(error_message)
+          error_message[/key '([^']+)'/, 1]
+        end
 
-      def unique_error_columns(error_message)
-        find_index_by_name(index_name(error_message)).columns
-      end
+        def unique_error_columns(_error_message); end
 
-      def foreign_key_error_column(error_message)
-        error_message[/FOREIGN KEY \(`([^`]+)`\)/, 1]
+        def foreign_key_error_column(error_message)
+          error_message[/FOREIGN KEY \(`([^`]+)`\)/, 1]
+        end
       end
     end
   end

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

@@ -4,16 +4,18 @@ module DatabaseValidations
       SUPPORTED_OPTIONS = %i[scope message where if unless index_name case_sensitive].freeze
       ADAPTER = :postgresql
 
-      def index_name(error_message)
-        error_message[/unique constraint "([^"]+)"/, 1]
-      end
+      class << self
+        def unique_index_name(error_message)
+          error_message[/unique constraint "([^"]+)"/, 1]
+        end
 
-      def unique_error_columns(error_message)
-        find_index_by_name(index_name(error_message)).columns
-      end
+        def unique_error_columns(error_message)
+          error_message[/Key \((.+)\)=/, 1].split(', ')
+        end
 
-      def foreign_key_error_column(error_message)
-        error_message[/Key \(([^)]+)\)/, 1]
+        def foreign_key_error_column(error_message)
+          error_message[/Key \(([^)]+)\)/, 1]
+        end
       end
     end
   end

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

@@ -4,18 +4,16 @@ module DatabaseValidations
       SUPPORTED_OPTIONS = %i[scope message if unless].freeze
       ADAPTER = :sqlite3
 
-      def index_name(_error_message); end
+      class << self
+        def unique_index_name(_error_message); end
 
-      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 unique_error_columns(error_message)
+          error_message.scan(/\w+\.([^,:]+)/).flatten
+        end
 
-      def foreign_key_error_column(error_message)
-        error_message[/\("([^"]+)"\) VALUES/, 1]
+        def foreign_key_error_column(error_message)
+          error_message[/\("([^"]+)"\) VALUES/, 1]
+        end
       end
     end
   end

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

@@ -3,13 +3,13 @@ module DatabaseValidations
     def db_belongs_to(name, scope = nil, **options)
       Helpers.cache_valid_method!(self)
 
-      @database_validations_opts ||= DatabaseValidations::OptionsStorage.new(self)
+      @database_validations_storage ||= 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)
+      @database_validations_storage.push_belongs_to(foreign_key, name)
 
       validates_with DatabaseValidations::DBPresenceValidator,
                      DatabaseValidations::BelongsToOptions.validator_options(name, foreign_key)

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

@@ -17,12 +17,7 @@ module DatabaseValidations
 
     # @return [String]
     def key
-      Helpers.generate_key_for_belongs_to(column)
-    end
-
-    # @return [Boolean]
-    def column_and_relation_blank_for?(instance)
-      instance.public_send(column).blank? && instance.public_send(relation).blank?
+      @key ||= Helpers.generate_key_for_belongs_to(column)
     end
 
     def handle_foreign_key_error(instance)

data/lib/database_validations/lib/errors.rb

@@ -59,7 +59,7 @@ module DatabaseValidations
         @column = column
         @foreign_keys = foreign_keys
 
-        super "No foreign key found with column: \"#{column}\". Founded foreign keys are: #{foreign_keys}. " + env_message
+        super "No foreign key found with column: \"#{column}\". Found foreign keys are: #{foreign_keys}. " + env_message
       end
     end
 

data/lib/database_validations/lib/helpers.rb

@@ -18,14 +18,16 @@ module DatabaseValidations
       end
     end
 
-    def handle_unique_error!(instance, error) # rubocop:disable Metrics/AbcSize
+    def handle_unique_error!(instance, error)
       adapter = Adapters.factory(instance.class)
-      index_key = generate_key_for_uniqueness_index(adapter.index_name(error.message))
-      column_key = generate_key_for_uniqueness(adapter.unique_error_columns(error.message))
+
+      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|
-        return storage[index_key].handle_unique_error(instance) if storage[index_key]
-        return storage[column_key].handle_unique_error(instance) if storage[column_key]
+        keys.each { |key| return storage[key].handle_unique_error(instance) if storage[key] }
       end
 
       false
@@ -44,26 +46,18 @@ module DatabaseValidations
 
     def each_options_storage(klass)
       while klass.respond_to?(:validates_db_uniqueness_of)
-        storage = klass.instance_variable_get(:'@database_validations_opts')
+        storage = storage_of(klass)
         yield(storage) if storage
         klass = klass.superclass
       end
     end
 
-    def each_uniqueness_validator(klass)
-      each_options_storage(klass) do |storage|
-        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
+    def storage_of(klass)
+      klass.instance_variable_get(:'@database_validations_storage')
     end
 
-    def unify_columns(*columns)
-      columns.flatten.compact.map(&:to_s).sort
+    def unify_columns(*args)
+      args.flatten.compact.map(&:to_s).sort
     end
 
     def generate_key_for_uniqueness_index(index_name)
@@ -78,8 +72,8 @@ module DatabaseValidations
       generate_key(:belongs_to, column)
     end
 
-    def generate_key(type, *columns)
-      [type, *unify_columns(columns)].join('__')
+    def generate_key(type, *args)
+      [type, *unify_columns(args)].join('__')
     end
   end
 end

data/lib/database_validations/lib/options_storage.rb

@@ -1,13 +1,14 @@
 module DatabaseValidations
   class OptionsStorage
     def initialize(klass)
-      @adapter = Adapters.factory(klass)
+      @adapter = Adapters.factory(klass).new(klass)
       @storage = {}
     end
 
     def push_uniqueness(field, options)
       uniqueness_options = UniquenessOptions.new(field, options, adapter)
-      storage[uniqueness_options.key] = uniqueness_options
+      storage[uniqueness_options.index_key] = uniqueness_options
+      storage[uniqueness_options.column_key] = uniqueness_options
     end
 
     def push_belongs_to(field, relation)
@@ -19,12 +20,8 @@ module DatabaseValidations
       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) }
+    def options
+      storage.values
     end
 
     private

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

@@ -3,12 +3,12 @@ module DatabaseValidations
     def validates_db_uniqueness_of(*attributes)
       Helpers.cache_valid_method!(self)
 
-      @database_validations_opts ||= DatabaseValidations::OptionsStorage.new(self)
+      @database_validations_storage ||= DatabaseValidations::OptionsStorage.new(self)
 
       options = attributes.extract_options!
 
       attributes.each do |attribute|
-        @database_validations_opts.push_uniqueness(attribute, options.merge(attributes: attribute))
+        @database_validations_storage.push_uniqueness(attribute, options.merge(attributes: attribute))
       end
 
       validates_with DatabaseValidations::DBUniquenessValidator,

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

@@ -11,7 +11,7 @@ module DatabaseValidations
         .tap { |opts| opts[:conditions] = -> { where(options[:where]) } if options[:where] }
     end
 
-    attr_reader :field
+    attr_reader :field, :calculated_index_name
 
     def initialize(field, options, adapter)
       @field = field
@@ -19,7 +19,13 @@ module DatabaseValidations
       @adapter = adapter
 
       raise_if_unsupported_options!
-      raise_if_index_missed! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
+
+      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)
@@ -30,8 +36,13 @@ module DatabaseValidations
     end
 
     # @return [String]
-    def key
-      @key ||= index_name ? Helpers.generate_key_for_uniqueness_index(index_name) : Helpers.generate_key_for_uniqueness(columns)
+    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>]
@@ -76,11 +87,12 @@ module DatabaseValidations
       end
     end
 
-    def raise_if_index_missed! # rubocop:disable Metrics/AbcSize
-      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, adapter.table_name)
-      end
+    def responsible_index
+      index_name ? adapter.find_index_by_name(index_name.to_s) : adapter.find_index(columns, where_clause)
+    end
+
+    def raise_if_index_missed!(index)
+      raise Errors::IndexNotFound.new(columns, where_clause, index_name, adapter.indexes, adapter.table_name) unless index
     end
   end
 end

data/lib/database_validations/rspec/uniqueness_validator_matcher.rb

@@ -46,15 +46,17 @@ RSpec::Matchers.define :validate_db_uniqueness_of do |field| # rubocop:disable M
 
     model = object.is_a?(Class) ? object : object.class
 
-    DatabaseValidations::Helpers.each_uniqueness_validator(model) do |validator|
-      @validators << {
-        field: validator.field,
-        scope: validator.scope,
-        where: validator.where_clause,
-        message: validator.message,
-        index_name: validator.index_name,
-        case_sensitive: validator.case_sensitive
-      }
+    DatabaseValidations::Helpers.each_options_storage(model) do |storage|
+      storage.options.grep(DatabaseValidations::UniquenessOptions).each do |validator|
+        @validators << {
+          field: validator.field,
+          scope: validator.scope,
+          where: validator.where_clause,
+          message: validator.message,
+          index_name: validator.index_name,
+          case_sensitive: validator.case_sensitive
+        }
+      end
     end
 
     @validators.include?(

data/lib/database_validations/version.rb

@@ -1,3 +1,3 @@
 module DatabaseValidations
-  VERSION = '0.8.6'.freeze
+  VERSION = '0.8.9'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_validations
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.9
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-11 00:00:00.000000000 Z
+date: 2019-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord