Ruby on Rails 5.2 - ActiveModel::Errors

वर्ग ActiveModel :: त्रुटियां




ruby

वर्ग ActiveModel :: त्रुटियां

जनक:
Object
शामिल मॉड्यूल:
Enumerable

सक्रिय मॉडल त्रुटियां

एक संशोधित Hash प्रदान करता है जिसे आप त्रुटि संदेशों से निपटने और एक्शन व्यू हेल्पर्स के साथ बातचीत करने के लिए अपनी वस्तु में शामिल कर सकते हैं।

एक न्यूनतम कार्यान्वयन हो सकता है:

class Person
  # Required dependency for ActiveModel::Errors
  extend ActiveModel::Naming

  def initialize
    @errors = ActiveModel::Errors.new(self)
  end

  attr_accessor :name
  attr_reader   :errors

  def validate!
    errors.add(:name, :blank, message: "cannot be nil") if name.nil?
  end

  # The following methods are needed to be minimally implemented

  def read_attribute_for_validation(attr)
    send(attr)
  end

  def self.human_attribute_name(attr, options = {})
    attr
  end

  def self.lookup_ancestors
    [self]
  end
end

Errors लिए सही तरीके से त्रुटि संदेश उत्पन्न करने और कई भाषाओं को संभालने में सक्षम होने के लिए आपकी वस्तु में अंतिम तीन तरीकों की आवश्यकता होती है। बेशक, यदि आप ActiveModel::Translation साथ अपनी वस्तु का विस्तार करते हैं ActiveModel::Translation आपको अंतिम दो को लागू करने की आवश्यकता नहीं होगी। इसी तरह, ActiveModel::Validations मान्यताओं का उपयोग करते हुए सत्यापन आपके लिए मान्यता संबंधी तरीकों को संभाल लेगा।

उपरोक्त आपको करने की अनुमति देता है:

person = Person.new
person.validate!            # => ["cannot be nil"]
person.errors.full_messages # => ["name cannot be nil"]
# etc..

स्थिरांक

CALLBACKS_OPTIONS
MESSAGE_OPTIONS

गुण

विवरण [आर]
संदेश [R]

पब्लिक क्लास के तरीके

नया (आधार) दिखाएँ स्रोत
# File activemodel/lib/active_model/errors.rb, line 74
def initialize(base)
  @base     = base
  @messages = apply_default_array({})
  @details = apply_default_array({})
end

उस ऑब्जेक्ट के उदाहरण में पास करें जो त्रुटियों ऑब्जेक्ट का उपयोग कर रहा है।

class Person
  def initialize
    @errors = ActiveModel::Errors.new(self)
  end
end

सार्वजनिक प्रवृत्ति के तरीके

[] (विशेषता) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 149
def [](attribute)
  messages[attribute.to_sym]
end

जब एक प्रतीक या किसी विधि का नाम पारित किया जाता है, तो विधि के लिए त्रुटियों की एक सरणी देता है।

person.errors[:name]  # => ["cannot be nil"]
person.errors['name'] # => ["cannot be nil"]
जोड़ें (विशेषता, संदेश =: अमान्य, विकल्प = {}) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 295
def add(attribute, message = :invalid, options = {})
  message = message.call if message.respond_to?(:call)
  detail  = normalize_detail(message, options)
  message = normalize_message(attribute, message, options)
  if exception = options[:strict]
    exception = ActiveModel::StrictValidationFailed if exception == true
    raise exception, full_message(attribute, message)
  end

  details[attribute.to_sym]  << detail
  messages[attribute.to_sym] << message
end

त्रुटि संदेशों को message जोड़ता है और attribute पर details लिए सत्यापनकर्ता प्रकार का उपयोग करता attribute । एक से अधिक त्रुटि को एक ही attribute जोड़ा जा सकता है। यदि कोई message नहीं दिया गया है, तो :invalid मान लिया गया है।

person.errors.add(:name)
# => ["is invalid"]
person.errors.add(:name, :not_implemented, message: "must be implemented")
# => ["is invalid", "must be implemented"]

person.errors.messages
# => {:name=>["is invalid", "must be implemented"]}

person.errors.details
# => {:name=>[{error: :not_implemented}, {error: :invalid}]}

यदि message एक प्रतीक है, तो इसका उपयुक्त दायरे में उपयोग करके अनुवाद किया जाएगा (देखें generate_message )।

यदि message एक खरीद है, तो उसे कॉल किया जाएगा, जो Time.now जैसी चीजों को एक त्रुटि के भीतर उपयोग करने की अनुमति देगा।

यदि :strict विकल्प true , तो यह ActiveModel::StrictValidationFailed को बढ़ा देगा ActiveModel::StrictValidationFailed त्रुटि को जोड़ने के बजाय ActiveModel::StrictValidationFailed गया। :strict विकल्प को किसी अन्य अपवाद पर भी सेट किया जा सकता है।

person.errors.add(:name, :invalid, strict: true)
# => ActiveModel::StrictValidationFailed: Name is invalid
person.errors.add(:name, :invalid, strict: NameIsInvalid)
# => NameIsInvalid: Name is invalid

person.errors.messages # => {}

attribute को सेट किया जाना चाहिए :base यदि त्रुटि सीधे एकल विशेषता के साथ संबद्ध नहीं है, तो :base को :base बनाया जाना चाहिए।

person.errors.add(:base, :name_or_email_blank,
  message: "either name or email must be present")
person.errors.messages
# => {:base=>["either name or email must be present"]}
person.errors.details
# => {:base=>[{error: :name_or_email_blank}]}
जोड़ा? (विशेषता, संदेश =: अमान्य, विकल्प = {}) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 324
def added?(attribute, message = :invalid, options = {})
  message = message.call if message.respond_to?(:call)

  if message.is_a? Symbol
    details[attribute.to_sym].include? normalize_detail(message, options)
  else
    self[attribute].include? message
  end
end

यदि दिए गए संदेश के साथ विशेषता पर कोई त्रुटि मौजूद है या false है तो सही है। message को add लिए समान माना जाता है।

person.errors.add :name, :blank
person.errors.added? :name, :blank           # => true
person.errors.added? :name, "can't be blank" # => true

यदि त्रुटि संदेश के लिए विकल्प की आवश्यकता होती है, तो यह सही विकल्प के साथ सही है, या गलत या लापता विकल्प के साथ गलत है।

person.errors.add :name, :too_long, { count: 25 }
person.errors.added? :name, :too_long, count: 25                     # => true
person.errors.added? :name, "is too long (maximum is 25 characters)" # => true
person.errors.added? :name, :too_long, count: 24                     # => false
person.errors.added? :name, :too_long                                # => false
person.errors.added? :name, "is too long"                            # => false
as_json (विकल्प = nil) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 235
def as_json(options = nil)
  to_hash(options && options[:full_messages])
end

इस ऑब्जेक्ट के लिए JSON प्रतिनिधित्व के रूप में उपयोग किया जा सकने वाला Hash लौटाता है। आप :full_messages विकल्प पास कर सकते हैं। यह निर्धारित करता है कि अगर json ऑब्जेक्ट में पूर्ण संदेश होना चाहिए या नहीं (डिफ़ॉल्ट रूप से गलत)।

person.errors.as_json                      # => {:name=>["cannot be nil"]}
person.errors.as_json(full_messages: true) # => {:name=>["name cannot be nil"]}
खाली? ()
अन्य के लिए उपनाम: empty?
# File activemodel/lib/active_model/errors.rb, line 115
def clear
  messages.clear
  details.clear
end

त्रुटि संदेश साफ़ करें।

person.errors.full_messages # => ["name cannot be nil"]
person.errors.clear
person.errors.full_messages # => []
गिनती ()
के लिए उपनाम: size
हटाएँ (कुंजी) स्रोत दिखाएँ
# File activemodel/lib/active_model/errors.rb, line 138
def delete(key)
  attribute = key.to_sym
  details.delete(attribute)
  messages.delete(attribute)
end

key लिए संदेश हटाएं। हटाए गए संदेशों को लौटाता है।

person.errors[:name]        # => ["cannot be nil"]
person.errors.delete(:name) # => ["cannot be nil"]
person.errors[:name]        # => []
प्रत्येक () {| विशेषता, त्रुटि | ...} स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 167
def each
  messages.each_key do |attribute|
    messages[attribute].each { |error| yield attribute, error }
  end
end

प्रत्येक त्रुटि कुंजी के माध्यम से इरेट करता है, त्रुटि संदेशों में वैल्यू पेयर हैश। उस विशेषता के लिए गुण और त्रुटि देता है। यदि विशेषता में एक से अधिक त्रुटि संदेश है, तो प्रत्येक त्रुटि संदेश के लिए एक बार उपज मिलती है।

person.errors.add(:name, :blank, message: "can't be blank")
person.errors.each do |attribute, error|
  # Will yield :name and "can't be blank"
end

person.errors.add(:name, :not_specified, message: "must be specified")
person.errors.each do |attribute, error|
  # Will yield :name and "can't be blank"
  # then yield :name and "must be specified"
end
# File activemodel/lib/active_model/errors.rb, line 209
def empty?
  size.zero?
end

यदि कोई त्रुटि नहीं मिलती है, तो true है, अन्यथा false है। यदि त्रुटि संदेश एक स्ट्रिंग है तो यह खाली हो सकता है।

person.errors.full_messages # => ["name cannot be nil"]
person.errors.empty?        # => false
के रूप में भी उपनाम: blank?
full_message (विशेषता, संदेश) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 367
def full_message(attribute, message)
  return message if attribute == :base
  attr_name = attribute.to_s.tr(".", "_").humanize
  attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
  I18n.t(:"errors.format",
    default:  "%{attribute} %{message}",
    attribute: attr_name,
    message:   message)
end

किसी दिए गए विशेषता के लिए एक पूर्ण संदेश देता है।

person.errors.full_message(:name, 'is invalid') # => "Name is invalid"
# File activemodel/lib/active_model/errors.rb, line 344
def full_messages
  map { |attribute, message| full_message(attribute, message) }
end

एक सरणी में सभी पूर्ण त्रुटि संदेश देता है।

class Person
  validates_presence_of :name, :address, :email
  validates_length_of :name, in: 5..30
end

person = Person.create(address: '123 First St.')
person.errors.full_messages
# => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
के रूप में भी उपनाम: to_a
full_messages_for (विशेषता) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 359
def full_messages_for(attribute)
  attribute = attribute.to_sym
  messages[attribute].map { |message| full_message(attribute, message) }
end

किसी सरणी में दिए गए विशेषता के लिए सभी पूर्ण त्रुटि संदेश देता है।

class Person
  validates_presence_of :name, :email
  validates_length_of :name, in: 5..30
end

person = Person.create()
person.errors.full_messages_for(:name)
# => ["Name is too short (minimum is 5 characters)", "Name can't be blank"]
Gener_message (विशेषता, प्रकार =: अमान्य, विकल्प = {}) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 401
def generate_message(attribute, type = :invalid, options = {})
  type = options.delete(:message) if options[:message].is_a?(Symbol)

  if @base.class.respond_to?(:i18n_scope)
    i18n_scope = @base.class.i18n_scope.to_s
    defaults = @base.class.lookup_ancestors.flat_map do |klass|
      [ :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
        :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
    end
    defaults << :"#{i18n_scope}.errors.messages.#{type}"
  else
    defaults = []
  end

  defaults << :"errors.attributes.#{attribute}.#{type}"
  defaults << :"errors.messages.#{type}"

  key = defaults.shift
  defaults = options.delete(:message) if options[:message]
  value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)

  options = {
    default: defaults,
    model: @base.model_name.human,
    attribute: @base.class.human_attribute_name(attribute),
    value: value,
    object: @base
  }.merge!(options)

  I18n.translate(key, options)
end

एक त्रुटि संदेश को उसके डिफ़ॉल्ट दायरे में ( activemodel.errors.messages ) अनुवाद करता है।

त्रुटि संदेश सबसे पहले activemodel.errors.models.MODEL.attributes.ATTRIBUTE.MESSAGE में activemodel.errors.models.MODEL.attributes.ATTRIBUTE.MESSAGE , यदि यह नहीं है, तो यह activemodel.errors.models.MODEL.MESSAGE में देखा गया है और यदि ऐसा नहीं है, तो यह वापस आ जाता है डिफ़ॉल्ट संदेश का अनुवाद (उदाहरण के लिए activemodel.errors.messages.MESSAGE )। अनुवादित मॉडल का नाम, अनुवादित विशेषता नाम और मूल्य प्रक्षेप के लिए उपलब्ध हैं।

अपने मॉडलों में वंशानुक्रम का उपयोग करते समय, यह सभी विरासत में मिले मॉडल की भी जाँच करेगा, लेकिन केवल तब जब मॉडल स्वयं नहीं मिला हो। कहते हैं कि आपके पास class Admin < User; end class Admin < User; end और आप अनुवाद चाहते थे :blank title विशेषता के लिए :blank त्रुटि संदेश, यह इन अनुवादों के लिए दिखता है:

  • activemodel.errors.models.admin.attributes.title.blank

  • activemodel.errors.models.admin.blank

  • activemodel.errors.models.user.attributes.title.blank

  • activemodel.errors.models.user.blank

  • आपके द्वारा options हैश के माध्यम से प्रदान की गई कोई भी डिफ़ॉल्ट ( activemodel.errors स्कोप में)

  • activemodel.errors.messages.blank

  • errors.attributes.title.blank

  • errors.messages.blank

has_key? (विशेषता)
इसके लिए उपनाम: include?
शामिल? (विशेषता) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 126
def include?(attribute)
  attribute = attribute.to_sym
  messages.key?(attribute) && messages[attribute].present?
end

यदि त्रुटि संदेश दिए गए कुंजी attribute लिए कोई त्रुटि शामिल true तो true , अन्यथा false है।

person.errors.messages        # => {:name=>["cannot be nil"]}
person.errors.include?(:name) # => true
person.errors.include?(:age)  # => false
इसके अलावा उपनाम: has_key? , key?
कुंजी? (विशेषता)
इसके लिए उपनाम: include?
चाबियाँ () स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 198
def keys
  messages.select do |key, value|
    !value.empty?
  end.keys
end

सभी संदेश कुंजी देता है।

person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
person.errors.keys     # => [:name]
विलय! (अन्य) स्रोत दिखाएँ
# File activemodel/lib/active_model/errors.rb, line 105
def merge!(other)
  @messages.merge!(other.messages) { |_, ary1, ary2| ary1 + ary2 }
  @details.merge!(other.details) { |_, ary1, ary2| ary1 + ary2 }
end

other से त्रुटियों को जोड़ता है।

अन्य - ActiveModel::Errors उदाहरण।

उदाहरण

person.errors.merge!(other)
# File activemodel/lib/active_model/errors.rb, line 179
def size
  values.flatten.size
end

त्रुटि संदेशों की संख्या लौटाता है।

person.errors.add(:name, :blank, message: "can't be blank")
person.errors.size # => 1
person.errors.add(:name, :not_specified, message: "must be specified")
person.errors.size # => 2
इसके अलावा उपनाम: count
to_a ()
इसके लिए उपनाम: full_messages
to_hash (full_messages = false) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 244
def to_hash(full_messages = false)
  if full_messages
    messages.each_with_object({}) do |(attribute, array), messages|
      messages[attribute] = array.map { |message| full_message(attribute, message) }
    end
  else
    without_default_proc(messages)
  end
end

अपनी त्रुटि संदेशों के साथ विशेषताओं का एक Hash लौटाता है। यदि full_messages true , तो इसमें पूर्ण संदेश होंगे (देखें full_message )।

person.errors.to_hash       # => {:name=>["cannot be nil"]}
person.errors.to_hash(true) # => {:name=>["name cannot be nil"]}
to_xml (विकल्प = {}) स्रोत दिखाएं
# File activemodel/lib/active_model/errors.rb, line 225
def to_xml(options = {})
  to_a.to_xml({ root: "errors", skip_types: true }.merge!(options))
end

एक xml ActiveModel::Errors हैश का निरूपण प्रस्तुत करता है।

person.errors.add(:name, :blank, message: "can't be blank")
person.errors.add(:name, :not_specified, message: "must be specified")
person.errors.to_xml
# =>
#  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
#  <errors>
#    <error>name can't be blank</error>
#    <error>name must be specified</error>
#  </errors>
# File activemodel/lib/active_model/errors.rb, line 188
def values
  messages.select do |key, value|
    !value.empty?
  end.values
end

सभी संदेश मान लौटाता है।

person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
person.errors.values   # => [["cannot be nil", "must be specified"]]