Class: ActiveRecord::Validations::UniquenessValidator
Do not use. This class is for internal use only.
Relationships & Source Files | |
Super Chains via Extension / Inclusion / Inheritance | |
Class Chain:
|
|
Instance Chain:
|
|
Inherits: |
ActiveModel::EachValidator
|
Defined in: | activerecord/lib/active_record/validations/uniqueness.rb |
Class Method Summary
- .new(options) ⇒ UniquenessValidator constructor
::ActiveModel::EachValidator
- Inherited
.new | Returns a new validator instance. |
::ActiveModel::Validator
- Inherited
Instance Attribute Summary
Instance Method Summary
- #validate_each(record, attribute, value)
- #build_relation(klass, attribute, value) private
- #covered_by_unique_index?(klass, record, attribute, scope) ⇒ Boolean private
-
#find_finder_class_for(record)
private
The check for an existing value should be run from a class that isn’t abstract.
- #map_enum_attribute(klass, attribute, value) private
- #resolve_attributes(record, attributes) private
- #scope_relation(record, relation) private
- #validation_needed?(klass, record, attribute) ⇒ Boolean private
::ActiveModel::EachValidator
- Inherited
#check_validity! | Hook method that gets called by the initializer allowing verification that the arguments supplied are valid. |
#validate | Performs validation on the supplied record. |
#validate_each | Override this method in subclasses with the validation logic, adding errors to the records |
#prepare_value_for_validation |
::ActiveModel::Validator
- Inherited
Constructor Details
.new(options) ⇒ UniquenessValidator
# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 6
def initialize( ) if [:conditions] && ! [:conditions].respond_to?(:call) raise ArgumentError, "#{ [:conditions]} was passed as :conditions but is not callable. " \ "Pass a callable instead: `conditions: -> { where(approved: true) }`" end unless Array( [:scope]).all? { |scope| scope.respond_to?(:to_sym) } raise ArgumentError, "#{ [:scope]} is not supported format for :scope option. " \ "Pass a symbol or an array of symbols instead: `scope: :user_id`" end super @klass = [:class] @klass = @klass.superclass if @klass.singleton_class? end
Instance Method Details
#build_relation(klass, attribute, value) (private)
[ GitHub ]# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 112
def build_relation(klass, attribute, value) relation = klass.unscoped # TODO: Add case-sensitive / case-insensitive operators to Arel # to no longer need to checkout a connection here. comparison = klass.with_connection do |connection| relation.bind_attribute(attribute, value) do |attr, bind| return relation.none! if bind.unboundable? if ! .key?(:case_sensitive) || bind.nil? connection.default_uniqueness_comparison(attr, bind) elsif [:case_sensitive] connection.case_sensitive_comparison(attr, bind) else # will use SQL LOWER function before comparison, unless it detects a case insensitive collation connection.case_insensitive_comparison(attr, bind) end end end relation.where!(comparison) end
#covered_by_unique_index?(klass, record, attribute, scope) ⇒ Boolean
(private)
# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 83
def covered_by_unique_index?(klass, record, attribute, scope) @covered ||= self.attributes.map(&:to_s).select do |attr| attributes = scope + [attr] attributes = resolve_attributes(record, attributes) klass.schema_cache.indexes(klass.table_name).any? do |index| index.unique && index.where.nil? && (Array(index.columns) - attributes).empty? end end @covered.include?(attribute.to_s) end
#find_finder_class_for(record) (private)
The check for an existing value should be run from a class that isn’t abstract. This means working down from the current class (self), to the first non-abstract class.
# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 58
def find_finder_class_for(record) current_class = record.class found_class = nil loop do found_class = current_class unless current_class.abstract_class? break if current_class == @klass current_class = current_class.superclass end found_class end
#map_enum_attribute(klass, attribute, value) (private)
[ GitHub ]# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 147
def map_enum_attribute(klass, attribute, value) mapping = klass.defined_enums[attribute.to_s] value = mapping[value] if value && mapping value end
#resolve_attributes(record, attributes) (private)
[ GitHub ]# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 98
def resolve_attributes(record, attributes) attributes.flat_map do |attribute| reflection = record.class._reflect_on_association(attribute) if reflection.nil? attribute.to_s elsif reflection.polymorphic? [reflection.foreign_key, reflection.foreign_type] else reflection.foreign_key end end end
#scope_relation(record, relation) (private)
[ GitHub ]# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 134
def scope_relation(record, relation) Array( [:scope]).each do |scope_item| scope_value = if record.class._reflect_on_association(scope_item) record.association(scope_item).reader else record.read_attribute(scope_item) end relation = relation.where(scope_item => scope_value) end relation end
#validate_each(record, attribute, value)
[ GitHub ]# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 20
def validate_each(record, attribute, value) finder_class = find_finder_class_for(record) value = map_enum_attribute(finder_class, attribute, value) return if record.persisted? && !validation_needed?(finder_class, record, attribute) relation = build_relation(finder_class, attribute, value) if record.persisted? if finder_class.primary_key relation = relation.where.not(finder_class.primary_key => [record.id_in_database]) else raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.") end end relation = scope_relation(record, relation) if [:conditions] conditions = [:conditions] relation = if conditions.arity.zero? relation.instance_exec(&conditions) else relation.instance_exec(record, &conditions) end end if relation.exists? = .except(:case_sensitive, :scope, :conditions) [:value] = value record.errors.add(attribute, :taken, ** ) end end
#validation_needed?(klass, record, attribute) ⇒ Boolean
(private)
# File 'activerecord/lib/active_record/validations/uniqueness.rb', line 70
def validation_needed?(klass, record, attribute) return true if [:conditions] || .key?(:case_sensitive) scope = Array( [:scope]) attributes = scope + [attribute] attributes = resolve_attributes(record, attributes) return true if attributes.any? { |attr| record.attribute_changed?(attr) || record.read_attribute(attr).nil? } !covered_by_unique_index?(klass, record, attribute, scope) end