Ruby on Rails 5.2 - ActiveModel::Dirty

मॉड्यूल ActiveModel :: गंदा




ruby

मॉड्यूल ActiveModel :: गंदा

शामिल मॉड्यूल:
ActiveModel::AttributeMethods

एक्टिव मॉडल डर्टी

एक्टिव रिकॉर्ड करता है उसी तरह से अपनी वस्तु में परिवर्तन को ट्रैक करने का एक तरीका प्रदान करता है।

ActiveModel::Dirty को लागू करने की आवश्यकताएं ActiveModel::Dirty हैं:

  • include ActiveModel::Dirty को अपनी वस्तु में शामिल करें।

  • define_attribute_methods विधि को आप ट्रैक करना चाहते हैं उसे पास करने के लिए define_attribute_methods कॉल करें।

  • कॉल [attr_name]_will_change! ट्रैक किए गए विशेषता में प्रत्येक परिवर्तन से पहले।

  • परिवर्तनों के बने रहने के बाद कॉल changes_applied

  • जब आप परिवर्तन जानकारी को रीसेट करना चाहते हैं, तो clear_changes_information पर कॉल करें।

  • जब आप पिछले डेटा को पुनर्स्थापित करना चाहते हैं, तो restore_attributes कॉल करें।

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

class Person
  include ActiveModel::Dirty

  define_attribute_methods :name

  def initialize
    @name = nil
  end

  def name
    @name
  end

  def name=(val)
    name_will_change! unless val == @name
    @name = val
  end

  def save
    # do persistence work

    changes_applied
  end

  def reload!
    # get the values from the persistence layer

    clear_changes_information
  end

  def rollback!
    restore_attributes
  end
end

एक नव तात्कालिक Person वस्तु अपरिवर्तित है:

person = Person.new
person.changed? # => false

नाम बदलें:

person.name = 'Bob'
person.changed?       # => true
person.name_changed?  # => true
person.name_changed?(from: nil, to: "Bob") # => true
person.name_was       # => nil
person.name_change    # => [nil, "Bob"]
person.name = 'Bill'
person.name_change    # => [nil, "Bill"]

परिवर्तनों को सुरक्षित करें:

person.save
person.changed?      # => false
person.name_changed? # => false

परिवर्तन रीसेट करें:

person.previous_changes         # => {"name" => [nil, "Bill"]}
person.name_previously_changed? # => true
person.name_previous_change     # => [nil, "Bill"]
person.reload!
person.previous_changes         # => {}

परिवर्तनों को रोलबैक करें:

person.name = "Uncle Bob"
person.rollback!
person.name          # => "Bill"
person.name_changed? # => false

समान मान असाइन करने से विशेषता अपरिवर्तित हो जाती है:

person.name = 'Bill'
person.name_changed? # => false
person.name_change   # => nil

कौन सी विशेषताएँ बदल गई हैं?

person.name = 'Bob'
person.changed # => ["name"]
person.changes # => {"name" => ["Bill", "Bob"]}

यदि किसी विशेषता को इन-प्लेस संशोधित किया जाता है, तो [attribute_name]_will_change! का उपयोग करें [attribute_name]_will_change! यह देखने के लिए कि विशेषता बदल रही है। अन्यथा सक्रिय मॉडल इन-प्लेस विशेषताओं में परिवर्तनों को ट्रैक नहीं कर सकता है। ध्यान दें कि सक्रिय रिकॉर्ड स्वचालित रूप से इन-प्लेस संशोधनों का पता लगा सकता है। आपको [attribute_name]_will_change! कॉल करने की आवश्यकता नहीं है [attribute_name]_will_change! सक्रिय रिकॉर्ड मॉडल पर।

person.name_will_change!
person.name_change # => ["Bill", "Bill"]
person.name << 'y'
person.name_change # => ["Bill", "Billy"]

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

परिवर्तित () स्रोत दिखाएं
# File activemodel/lib/active_model/dirty.rb, line 170
def changed
  changed_attributes.keys
end

सहेजे गए परिवर्तनों के साथ विशेषताओं के नाम के साथ एक सरणी देता है।

person.changed # => []
person.name = 'bob'
person.changed # => ["name"]
बदला हुआ? () स्रोत दिखाएं
# File activemodel/lib/active_model/dirty.rb, line 161
def changed?
  changed_attributes.present?
end

यदि किसी भी विशेषता में परिवर्तन न किए गए हों, तो यह true , अन्यथा false है।

person.changed? # => false
person.name = 'bob'
person.changed? # => true
# File activemodel/lib/active_model/dirty.rb, line 218
def changed_attributes
  # This should only be set by methods which will call changed_attributes
  # multiple times when it is known that the computed value cannot change.
  if defined?(@cached_changed_attributes)
    @cached_changed_attributes
  else
    attributes_changed_by_setter.reverse_merge(mutations_from_database.changed_values).freeze
  end
end

गैर-परिवर्तन के साथ विशेषताओं का एक हैश लौटाता है, जो अपने मूल मानों जैसे कि attr => original value दर्शाता है।

person.name # => "bob"
person.name = 'robert'
person.changed_attributes # => {"name" => "bob"}
परिवर्तन () स्रोत दिखाएं
# File activemodel/lib/active_model/dirty.rb, line 234
def changes
  cache_changed_attributes do
    ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
  end
end

बदले हुए गुणों का एक हैश देता है जो अपने मूल और नए मानों को दर्शाता है जैसे attr => [original value, new value]

person.changes # => {}
person.name = 'bob'
person.changes # => { "name" => ["bill", "bob"] }
# File activemodel/lib/active_model/dirty.rb, line 146
def changes_applied
  unless defined?(@attributes)
    @previously_changed = changes
  end
  @mutations_before_last_save = mutations_from_database
  @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
  forget_attribute_assignments
  @mutations_from_database = nil
end

गंदे डेटा को previously_changed और क्रमशः changes करता है जो previously_changed mutations_from_database और mutations_from_database से क्रमशः mutations_before_last_save जाता है।

clear_attribute_changes (attr_names) स्रोत दिखाएँ
# File activemodel/lib/active_model/dirty.rb, line 205
def clear_attribute_changes(attr_names)
  attributes_changed_by_setter.except!(*attr_names)
  attr_names.each do |attr_name|
    clear_attribute_change(attr_name)
  end
end
clear_changes_information () स्रोत दिखाएं
# File activemodel/lib/active_model/dirty.rb, line 197
def clear_changes_information
  @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
  @mutations_before_last_save = nil
  @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
  forget_attribute_assignments
  @mutations_from_database = nil
end

सभी गंदे डेटा को साफ करता है: वर्तमान परिवर्तन और पिछले परिवर्तन।

# File activemodel/lib/active_model/dirty.rb, line 246
def previous_changes
  @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
  @previously_changed.merge(mutations_before_last_save.changes)
end

मॉडल सहेजे जाने से पहले बदले गए विशेषताओं का एक हैश लौटाता है।

person.name # => "bob"
person.name = 'robert'
person.save
person.previous_changes # => {"name" => ["bob", "robert"]}
पुनर्स्थापना_सुविधाएँ (विशेषताएँ = परिवर्तित) स्रोत दिखाएँ
# File activemodel/lib/active_model/dirty.rb, line 192
def restore_attributes(attributes = changed)
  attributes.each { |attr| restore_attribute! attr }
end

प्रदान की गई विशेषताओं के सभी पिछले डेटा को पुनर्स्थापित करें।