Ruby on Rails 5.2 - ActiveSupport::Callbacks::ClassMethods

मॉड्यूल ActiveSupport :: Callbacks :: ClassMethods




ruby

मॉड्यूल ActiveSupport :: Callbacks :: ClassMethods

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

define_callbacks (* नाम) स्रोत दिखाएं
# File activesupport/lib/active_support/callbacks.rb, line 806
        def define_callbacks(*names)
          options = names.extract_options!

          names.each do |name|
            name = name.to_sym

            set_callbacks name, CallbackChain.new(name, options)

            module_eval <<-RUBY, __FILE__, __LINE__ + 1
              def _run_#{name}_callbacks(&block)
                run_callbacks #{name.inspect}, &block
              end

              def self._#{name}_callbacks
                get_callbacks(#{name.inspect})
              end

              def self._#{name}_callbacks=(value)
                set_callbacks(#{name.inspect}, value)
              end

              def _#{name}_callbacks
                __callbacks[#{name.inspect}]
              end
            RUBY
          end
        end

कॉलबैक का समर्थन करने वाले ऑब्जेक्ट जीवन चक्र में घटनाओं के सेट को परिभाषित करें।

define_callbacks :validate
define_callbacks :initialize, :save, :destroy
विकल्प
  • :terminator - यह निर्धारित करता है कि जब एक पहले फिल्टर कॉलबैक श्रृंखला को रोक देगा, तो कॉलबैक से पहले और आस-पास को रोकने से और इवेंट को ट्रिगर होने से रोका जाएगा। इसे निष्पादित करने के लिए एक लंबोदर होना चाहिए। वर्तमान वस्तु और कॉलबैक के परिणाम लैम्बडा को टर्मिनेटर लैम्ब्डा को प्रदान किया जाएगा।

    define_callbacks :validate, terminator: ->(target, result_lambda) { result_lambda.call == false }
    

    इस उदाहरण में, यदि वैध कॉलबैक से पहले कोई भी false रिटर्न करता है, तो कॉलबैक से पहले और उसके आसपास किसी भी क्रम को निष्पादित नहीं किया जाता है।

    कॉलबैक फेंके जाने पर डिफ़ॉल्ट टर्मिनेटर चेन को :abort देता है :abort

  • :skip_after_callbacks_if_terminated - निर्धारित करता है कि कॉलबैक के बाद समाप्त किया जाना चाहिए :terminator विकल्प। कॉलबैक श्रृंखला समाप्त होने या न होने पर कॉलबैक के बाद डिफ़ॉल्ट रूप से निष्पादित किया जाता है। इस विकल्प का कोई प्रभाव नहीं पड़ता है यदि :terminator विकल्प nil सेट है।

  • :scope - इंगित करता है कि कॉलबैक के रूप में किसी ऑब्जेक्ट का उपयोग करने पर किन तरीकों को निष्पादित किया जाना चाहिए।

    class Audit
      def before(caller)
        puts 'Audit: before is called'
      end
    
      def before_save(caller)
        puts 'Audit: before_save is called'
      end
    end
    
    class Account
      include ActiveSupport::Callbacks
    
      define_callbacks :save
      set_callback :save, :before, Audit.new
    
      def save
        run_callbacks :save do
          puts 'save in main'
        end
      end
    end
    

    उपरोक्त मामले में जब भी आप किसी खाते को सहेजते हैं तो विधि Audit#before जाएगी। दूसरी ओर

    define_callbacks :save, scope: [:kind, :name]
    

    इसके बजाय Audit#before_save को ट्रिगर करेगा। इसका निर्माण दिए गए उदाहरण पर #{kind}_#{name} कहकर किया गया है। इस मामले में "दयालु" "पहले" है और "नाम" "बचाना" है। इस संदर्भ में :kind और :name विशेष अर्थ होते हैं: :kind तरह के कॉलबैक को संदर्भित करता है (पहले / बाद / उसके आसपास) और :name उस पद्धति को संदर्भित करता है जिस पर कॉलबैक परिभाषित किए जा रहे हैं।

    एक घोषणा की तरह

    define_callbacks :save, scope: [:name]
    

    Audit#save

टिप्पणियाँ

define_callbacks को names गए names साथ समाप्त नहीं होने चाहिए ! ? या =

एक ही names साथ कई बार define_callbacks कॉल करने से define_callbacks साथ पंजीकृत पिछली कॉलबैक ओवरराइट हो जाएगी।

reset_callbacks (नाम) स्रोत दिखाएं
# File activesupport/lib/active_support/callbacks.rb, line 716
def reset_callbacks(name)
  callbacks = get_callbacks name

  ActiveSupport::DescendantsTracker.descendants(self).each do |target|
    chain = target.get_callbacks(name).dup
    callbacks.each { |c| chain.delete(c) }
    target.set_callbacks name, chain
  end

  set_callbacks(name, callbacks.dup.clear)
end

दिए गए ईवेंट के लिए सभी सेट कॉलबैक निकालें।

set_callback (नाम, * filter_list, और ब्लॉक) दिखाएँ स्रोत
# File activesupport/lib/active_support/callbacks.rb, line 667
def set_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)

  self_chain = get_callbacks name
  mapped = filters.map do |filter|
    Callback.build(self_chain, filter, type, options)
  end

  __update_callbacks(name) do |target, chain|
    options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
    target.set_callbacks name, chain
  end
end

दिए गए ईवेंट के लिए कॉलबैक स्थापित करें।

set_callback :save, :before, :before_method
set_callback :save, :after,  :after_method, if: :condition
set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }

दूसरा तर्क इंगित करता है कि क्या कॉलबैक चलाया जाना है :before घटना के :before :after , या:। यदि छोड़ा गया है, तो :before मान लिया गया है। इसका अर्थ है कि ऊपर दिया गया पहला उदाहरण भी इस प्रकार लिखा जा सकता है:

set_callback :save, :before_method

कॉलबैक को एक उदाहरण विधि नाम के प्रतीक के रूप में निर्दिष्ट किया जा सकता है; एक खरीद के रूप में, लैम्ब्डा, या ब्लॉक; या उस ऑब्जेक्ट के रूप में जो एक निश्चित विधि के द्वारा निर्धारित होता है :scope define_callbacks लिए :scope तर्क।

यदि कोई खरीद, लंबोदर, या ब्लॉक दिया जाता है, तो उसके शरीर का मूल्यांकन वर्तमान वस्तु के संदर्भ में किया जाता है। यह वैकल्पिक रूप से वर्तमान वस्तु को एक तर्क के रूप में भी स्वीकार कर सकता है।

कॉलबैक से पहले और आस-पास उस क्रम में कॉल किया जाता है जिसे वे सेट करते हैं; कॉलबैक के बाद रिवर्स ऑर्डर में कॉल किया जाता है।

लगभग कॉलबैक ईवेंट वैल्यू से रिटर्न वैल्यू तक पहुँच सकता है, अगर यह yield कॉल से रुका नहीं था।

विकल्प
  • :if - एक प्रतीक या प्रतीकों की एक सरणी, प्रत्येक एक नामकरण विधि या एक खरीद; कॉलबैक तभी कहा जाएगा जब वे सभी एक सही मूल्य लौटाएंगे।

  • :unless - एक प्रतीक या प्रतीकों की एक सरणी, प्रत्येक एक नामकरण विधि या एक खरीद; कॉलबैक तभी कहा जाएगा जब वे सभी एक गलत मान लौटाएंगे।

  • :prepend - यदि true , तो कॉलबैक को संलग्न किए जाने के बजाय मौजूदा चेन से प्रीपेन्ड किया जाएगा।

Skip_callback (नाम, * filter_list, और ब्लॉक) शो स्रोत
# File activesupport/lib/active_support/callbacks.rb, line 691
def skip_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)

  options[:raise] = true unless options.key?(:raise)

  __update_callbacks(name) do |target, chain|
    filters.each do |filter|
      callback = chain.find { |c| c.matches?(type, filter) }

      if !callback && options[:raise]
        raise ArgumentError, "#{type.to_s.capitalize} #{name} callback #{filter.inspect} has not been defined"
      end

      if callback && (options.key?(:if) || options.key?(:unless))
        new_callback = callback.merge_conditional_options(chain, if_option: options[:if], unless_option: options[:unless])
        chain.insert(chain.index(callback), new_callback)
      end

      chain.delete(callback)
    end
    target.set_callbacks name, chain
  end
end

पहले वाले कॉलबैक को छोड़ें। जैसे कि set_callback :if या :unless कि कॉलबैक स्किप होने पर नियंत्रण करने के लिए विकल्प पारित नहीं किए जा सकते।

class Writer < Person
   skip_callback :validate, :before, :check_membership, if: -> { age > 18 }
end

यदि कॉलबैक पहले से सेट नहीं किया गया है (जब तक :raise false विकल्प सेट नहीं किया जाता false ) false होने पर एक ArgumentError हो जाएगी।