database_validations 0.8.5 → 0.9.1

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

@@ -1,22 +0,0 @@
-module DatabaseValidations
-  module Adapters
-    class SqliteAdapter < BaseAdapter
-      SUPPORTED_OPTIONS = %i[scope message if unless].freeze
-      ADAPTER = :sqlite3
-
-      def 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 foreign_key_error_column(error_message)
-        error_message[/\("([^"]+)"\) VALUES/, 1]
-      end
-    end
-  end
-end

data/lib/database_validations/validations/belongs_to_handlers.rb

@@ -1,58 +0,0 @@
-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|
-        next if validator.column_and_relation_blank_for?(self)
-
-        validates_with(ActiveRecord::Validations::PresenceValidator, validator.validates_presence_options)
-      end
-
-      errors.empty? && output
-    end
-
-    def save(opts = {})
-      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
-    rescue ActiveRecord::InvalidForeignKey => e
-      Helpers.handle_foreign_key_error!(self, e)
-      false
-    end
-
-    def save!(opts = {})
-      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
-
-      validates_with DatabaseValidations::Validations::BelongsToPresenceValidator, column: foreign_key, relation: name
-
-      @database_validations_opts.push_belongs_to(foreign_key, name)
-
-      include(DatabaseValidations::BelongsToHandlers)
-    end
-  end
-end

data/lib/database_validations/validations/belongs_to_options.rb

@@ -1,44 +0,0 @@
-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
-
-    # @return [Boolean]
-    def column_and_relation_blank_for?(instance)
-      instance.public_send(column).blank? && instance.public_send(relation).blank?
-    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!
-      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/validations/belongs_to_presence_validator.rb

@@ -1,25 +0,0 @@
-module DatabaseValidations
-  module Validations
-    class BelongsToPresenceValidator < ActiveModel::Validator
-      attr_reader :attributes
-
-      # 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
-
-      def initialize(options = {})
-        @attributes = [options[:relation]]
-        super
-      end
-
-      def validate(record)
-        return unless record.public_send(options[:column]).blank? && record.public_send(options[:relation]).blank?
-
-        record.errors.add(options[:relation], :blank, message: :required)
-      end
-    end
-  end
-end

data/lib/database_validations/validations/helpers.rb

@@ -1,69 +0,0 @@
-module DatabaseValidations
-  module Helpers
-    module_function
-
-    def handle_unique_error!(instance, error) # rubocop:disable Metrics/AbcSize
-      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))
-
-      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]
-      end
-
-      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 each_options_storage(klass)
-      while klass.respond_to?(:validates_db_uniqueness_of)
-        storage = klass.instance_variable_get(:'@database_validations_opts')
-        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
-    end
-
-    def unify_columns(*columns)
-      columns.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, *columns)
-      [type, *unify_columns(columns)].join('__')
-    end
-  end
-end

data/lib/database_validations/validations/options_storage.rb

@@ -1,34 +0,0 @@
-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_handlers.rb

@@ -1,56 +0,0 @@
-module DatabaseValidations
-  module UniquenessHandlers
-    extend ActiveSupport::Concern
-
-    included do
-      alias_method :validate, :valid?
-    end
-
-    def valid?(context = nil)
-      output = super(context)
-
-      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
-      end
-
-      errors.empty? && output
-    end
-
-    def save(options = {})
-      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
-    rescue ActiveRecord::RecordNotUnique => e
-      Helpers.handle_unique_error!(self, e)
-      false
-    end
-
-    def save!(options = {})
-      ActiveRecord::Base.connection.transaction(requires_new: true) { super }
-    rescue ActiveRecord::RecordNotUnique => e
-      Helpers.handle_unique_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 validates_db_uniqueness_of(*attributes)
-      include(DatabaseValidations::ValidWithoutDatabaseValidations)
-      @database_validations_opts ||= DatabaseValidations::OptionsStorage.new(self)
-
-      options = attributes.extract_options!
-
-      attributes.each do |attribute|
-        @database_validations_opts.push_uniqueness(attribute, options.merge(attributes: attribute))
-      end
-
-      include(DatabaseValidations::UniquenessHandlers)
-    end
-  end
-end

data/lib/database_validations/validations/uniqueness_options.rb

@@ -1,104 +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
-
-    attr_reader :field
-
-    def initialize(field, options, adapter)
-      @field = field
-      @options = options
-      @adapter = adapter
-
-      raise_if_unsupported_options!
-      raise_if_index_missed! unless ENV['SKIP_DB_UNIQUENESS_VALIDATOR_INDEX_CHECK']
-    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 [Hash<Symbol, Object>]
-    def validates_uniqueness_options
-      where_clause_str = where_clause
-
-      DEFAULT_OPTIONS
-        .merge(options)
-        .except(*CUSTOM_OPTIONS)
-        .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 ||= index_name ? Helpers.generate_key_for_uniqueness_index(index_name) : 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 condition_passes?(condition, instance)
-      if condition.is_a?(Symbol)
-        instance.__send__(condition)
-      elsif condition.is_a?(Proc) && condition.arity.zero?
-        instance.instance_exec(&condition)
-      else
-        instance.instance_eval(&condition)
-      end
-    end
-
-    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 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
-    end
-  end
-end

data/lib/database_validations/validations/valid_without_database_validations.rb

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