Ruby on Rails 5.2 - ActiveRecord::Aggregations::ClassMethods

मॉड्यूल ActiveRecord :: एकत्रीकरण :: ClassMethods




ruby

मॉड्यूल ActiveRecord :: एकत्रीकरण :: ClassMethods

सक्रिय रिकॉर्ड मूल्य-वस्तुओं के रूप में विशेषताओं का प्रतिनिधित्व करने के लिए एक समरूप-वर्ग नामक मैक्रो-क्लास विधि के माध्यम से एकत्रीकरण को लागू करता है। यह "खाता [है] जैसे रिश्तों को धन [अन्य चीजों के बीच] या" व्यक्ति []] [एक] पते से बना है। मैक्रो के लिए प्रत्येक कॉल में इस बात का वर्णन होता है कि इकाई ऑब्जेक्ट की विशेषताओं से मूल्य ऑब्जेक्ट कैसे बनाए जाते हैं (जब इकाई को किसी नई वस्तु के रूप में या किसी मौजूदा ऑब्जेक्ट को खोजने से आरंभ किया जाता है) और इसे वापस विशेषताओं में कैसे बदला जा सकता है ( जब इकाई डेटाबेस में सहेजी जाती है)।

class Customer < ActiveRecord::Base
  composed_of :balance, class_name: "Money", mapping: %w(balance amount)
  composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
end

ग्राहक वर्ग में अब मूल्य वस्तुओं में हेरफेर करने के लिए निम्नलिखित तरीके हैं:

  • Customer#balance, Customer#balance=(money)

  • Customer#address, Customer#address=(address)

ये विधियाँ नीचे वर्णित वस्तुओं की तरह मूल्य वस्तुओं के साथ संचालित होंगी:

class Money
  include Comparable
  attr_reader :amount, :currency
  EXCHANGE_RATES = { "USD_TO_DKK" => 6 }

  def initialize(amount, currency = "USD")
    @amount, @currency = amount, currency
  end

  def exchange_to(other_currency)
    exchanged_amount = (amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor
    Money.new(exchanged_amount, other_currency)
  end

  def ==(other_money)
    amount == other_money.amount && currency == other_money.currency
  end

  def <=>(other_money)
    if currency == other_money.currency
      amount <=> other_money.amount
    else
      amount <=> other_money.exchange_to(currency).amount
    end
  end
end

class Address
  attr_reader :street, :city
  def initialize(street, city)
    @street, @city = street, city
  end

  def close_to?(other_address)
    city == other_address.city
  end

  def ==(other_address)
    city == other_address.city && street == other_address.street
  end
end

अब इसके बजाय मूल्य वस्तुओं के माध्यम से डेटाबेस से विशेषताओं तक पहुंच संभव है। यदि आप संरचना का नाम विशेषता के नाम के समान चुनते हैं, तो यह उस विशेषता तक पहुंचने का एकमात्र तरीका होगा। हमारी balance विशेषता का यही हाल है। आप मूल्य वस्तुओं के साथ उसी तरह बातचीत करते हैं जैसे आप किसी अन्य विशेषता के साथ करेंगे:

customer.balance = Money.new(20)     # sets the Money value object and the attribute
customer.balance                     # => Money value object
customer.balance.exchange_to("DKK")  # => Money.new(120, "DKK")
customer.balance > Money.new(10)     # => true
customer.balance == Money.new(20)    # => true
customer.balance < Money.new(5)      # => false

मान ऑब्जेक्ट भी कई विशेषताओं से बना हो सकता है, जैसे पता। मैपिंग का क्रम मापदंडों के क्रम को निर्धारित करेगा।

customer.address_street = "Hyancintvej"
customer.address_city   = "Copenhagen"
customer.address        # => Address.new("Hyancintvej", "Copenhagen")

customer.address = Address.new("May Street", "Chicago")
customer.address_street # => "May Street"
customer.address_city   # => "Chicago"

मूल्य वस्तुओं को लिखना

मूल्य ऑब्जेक्ट अपरिवर्तनीय और विनिमेय ऑब्जेक्ट हैं जो किसी दिए गए मूल्य का प्रतिनिधित्व करते हैं, जैसे कि $ 5 का प्रतिनिधित्व करने वाली मनी ऑब्जेक्ट। $ 5 का प्रतिनिधित्व करने वाली दो मनी ऑब्जेक्ट्स बराबर होनी चाहिए (यदि रैंकिंग समझ में आती है तो तुलनीय से == और <=> जैसे तरीकों के माध्यम से)। यह इकाई वस्तुओं के विपरीत है जहां समानता पहचान द्वारा निर्धारित की जाती है। ग्राहक के रूप में एक इकाई वर्ग में आसानी से दो अलग-अलग ऑब्जेक्ट हो सकते हैं, जो दोनों को Hyancintvej पर एक पता है। इकाई की पहचान वस्तु या संबंधपरक विशिष्ट पहचानकर्ताओं (जैसे प्राथमिक कुंजी) द्वारा निर्धारित की जाती है। सामान्य ActiveRecord::Base कक्षाएं इकाई ऑब्जेक्ट हैं।

मूल्य की वस्तुओं को अपरिवर्तनीय मानना ​​भी महत्वपूर्ण है। मनी ऑब्जेक्ट को निर्माण के बाद अपनी राशि को बदलने की अनुमति न दें। इसके बजाय नए मूल्य के साथ एक नया मनी ऑब्जेक्ट बनाएं। Money#exchange_to विधि इसका एक उदाहरण है। यह अपने स्वयं के मूल्यों को बदलने के बजाय एक नया मूल्य वस्तु लौटाता है। सक्रिय रिकॉर्ड उन मान ऑब्जेक्ट को बनाए नहीं रखेगा जो लेखक विधि के अलावा अन्य माध्यमों से बदले गए हैं।

मूल्य रिकॉर्ड के रूप में सौंपी गई किसी भी वस्तु को फ्रीज़ करके सक्रिय रिकॉर्ड द्वारा अपरिवर्तनीय आवश्यकता को लागू किया जाता है। बाद में इसे बदलने का प्रयास एक RuntimeError में होगा।

c2.com/cgi/wiki?ValueObject पर मान ऑब्जेक्ट के बारे में और अधिक पढ़ें और c2.com/cgi/wiki?ValueObject पर मूल्य ऑब्जेक्ट अपरिवर्तनीय नहीं रखने के खतरों पर

कस्टम निर्माता और कन्वर्टर्स

डिफ़ॉल्ट मान ऑब्जेक्ट द्वारा मैप किए गए प्रत्येक गुण को पास करने वाले मान वर्ग के new कंस्ट्रक्टर को कॉल करके आरंभ किया जाता है :mapping तर्क द्वारा, :mapping विकल्प द्वारा निर्दिष्ट क्रम में। यदि मान वर्ग इस कन्वेंशन का समर्थन नहीं करता है, तो एक कस्टम कंस्ट्रक्टर निर्दिष्ट करने की अनुमति देता है।

जब कोई नया मान मान ऑब्जेक्ट को असाइन किया जाता है, तो डिफ़ॉल्ट धारणा यह है कि नया मान मूल्य वर्ग का एक उदाहरण है। कस्टम कनवर्टर निर्दिष्ट करने से नए मान को आवश्यक होने पर स्वचालित रूप से मूल्य वर्ग की एक आवृत्ति में परिवर्तित करने की अनुमति मिलती है।

उदाहरण के लिए, cidr_range मॉडल में network_address और cidr_range विशेषताएँ होती हैं जिन्हें NetAddr::CIDR मान वर्ग ( www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR ) का उपयोग करके एकत्र किया जाना चाहिए। मूल्य वर्ग के लिए निर्माणकर्ता को कहा जाता है और यह एक पैरामीटर के रूप में सीआईडीआर पता स्ट्रिंग की अपेक्षा करता है। नए मानों को किसी अन्य NetAddr::CIDR ऑब्जेक्ट, एक स्ट्रिंग या एक सरणी का उपयोग करके मूल्य ऑब्जेक्ट को सौंपा जा सकता है। इन आवश्यकताओं को पूरा करने के लिए :constructor और :converter विकल्पों का उपयोग किया जा सकता है:

class NetworkResource < ActiveRecord::Base
  composed_of :cidr,
              class_name: 'NetAddr::CIDR',
              mapping: [ %w(network_address network), %w(cidr_range bits) ],
              allow_nil: true,
              constructor: Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
              converter: Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
end

# This calls the :constructor
network_resource = NetworkResource.new(network_address: '192.168.0.1', cidr_range: 24)

# These assignments will both use the :converter
network_resource.cidr = [ '192.168.2.1', 8 ]
network_resource.cidr = '192.168.0.1/24'

# This assignment won't use the :converter as the value is already an instance of the value class
network_resource.cidr = NetAddr::CIDR.create('192.168.2.1/8')

# Saving and then reloading will use the :constructor on reload
network_resource.save
network_resource.reload

किसी मान ऑब्जेक्ट द्वारा रिकॉर्ड ढूँढना

एक बार जब एक मॉडल के लिए एक composed_of संबंध निर्दिष्ट किया जाता है, तो शर्तों में मूल्य वस्तु के एक उदाहरण को निर्दिष्ट करके डेटाबेस से रिकॉर्ड लोड किया जा सकता है। निम्नलिखित उदाहरण "मई स्ट्रीट" के समान address_city और "शिकागो" के बराबर address_street साथ सभी ग्राहकों को पाता है:

Customer.where(address: Address.new("May Street", "Chicago"))

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

रचित_ऑफ़ (part_id, विकल्प = {}) स्रोत दिखाएं
# File activerecord/lib/active_record/aggregations.rb, line 225
def composed_of(part_id, options = {})
  options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)

  name        = part_id.id2name
  class_name  = options[:class_name]  || name.camelize
  mapping     = options[:mapping]     || [ name, name ]
  mapping     = [ mapping ] unless mapping.first.is_a?(Array)
  allow_nil   = options[:allow_nil]   || false
  constructor = options[:constructor] || :new
  converter   = options[:converter]

  reader_method(name, class_name, mapping, allow_nil, constructor)
  writer_method(name, class_name, mapping, allow_nil, converter)

  reflection = ActiveRecord::Reflection.create(:composed_of, part_id, nil, options, self)
  Reflection.add_aggregate_reflection self, part_id, reflection
end

मान ऑब्जेक्ट में हेरफेर करने के लिए पाठक और लेखक के तरीकों को जोड़ता है composed_of :address address=(new_address) composed_of :address address और address=(new_address) जोड़ता है।

विकल्प हैं:

  • :class_name - संघ के वर्ग नाम को निर्दिष्ट करता है। इसका उपयोग केवल तभी करें जब वह नाम भाग आईडी से अनुमान नहीं लगाया जा सकता है। अतः composed_of :address डिफ़ॉल्ट रूप से पता वर्ग से जुड़ा होगा, लेकिन यदि वास्तविक वर्ग का नाम CompanyAddress , तो आपको इसे इस विकल्प के साथ निर्दिष्ट करना होगा।

  • :mapping - मान ऑब्जेक्ट की विशेषताओं के लिए इकाई विशेषताओं के मानचित्रण को निर्दिष्ट करता है। प्रत्येक मानचित्रण को एक सरणी के रूप में दर्शाया जाता है जहां पहला आइटम इकाई विशेषता का नाम है और दूसरा आइटम मूल्य ऑब्जेक्ट में विशेषता का नाम है। जिस क्रम में मैपिंग को परिभाषित किया गया है वह उस क्रम को निर्धारित करता है जिसमें विशेषताओं को मूल्य वर्ग के निर्माता को भेजा जाता है।

  • :allow_nil - निर्दिष्ट करता है कि सभी मैप किए गए विशेषताओं के nil होने पर मान ऑब्जेक्ट को :allow_nil नहीं किया जाएगा। मान ऑब्जेक्ट को nil सेट करने से सभी मैप की गई विशेषताओं के लिए nil लिखने का प्रभाव पड़ता है। यह false लिए चूक है।

  • :constructor - एक प्रतीक जो कंस्ट्रक्टर विधि या एक प्रोक के नाम को निर्दिष्ट करता है जिसे मूल्य ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कहा जाता है। कंस्ट्रक्टर को मैप की गई विशेषताओं के सभी पास किया जाता है, इस क्रम में कि वे परिभाषित किए गए हैं :mapping option , तर्क के रूप में और उन्हें उपयोग करने के लिए a :class_name ऑब्जेक्ट। डिफ़ॉल्ट है :new

  • :converter - एक वर्ग विधि के नाम को निर्दिष्ट करने वाला एक प्रतीक :class_name या एक प्रोक, जिसे तब कहा जाता है जब एक नया मान मान ऑब्जेक्ट को सौंपा जाता है। कनवर्टर को एकल मान दिया जाता है जिसका उपयोग असाइनमेंट में किया जाता है और इसे केवल तभी कहा जाता है यदि नया मान उदाहरण नहीं है :class_name । यदि :allow_nil सही पर सेट है, तो असाइनमेंट को छोड़ने के लिए कनवर्टर nil को लौटा सकता है।

विकल्प उदाहरण:

composed_of :temperature, mapping: %w(reading celsius)
composed_of :balance, class_name: "Money", mapping: %w(balance amount)
composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
composed_of :gps_location
composed_of :gps_location, allow_nil: true
composed_of :ip_address,
            class_name: 'IPAddr',
            mapping: %w(ip to_i),
            constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
            converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }