metaprogramming - Dynamic method definition in ruby -

क्या $ 1.to_sym = & gt; आर्ग [0] और ($ 1.to_sym, * args, और ब्लॉक) कोड की निम्न पंक्ति में करें?

  वर्ग तालिका def method_missing (Id, * args, और block) के रूप में वापसी ($ 1.to_sym, * args, और amp; ब्लॉक) अगर id.to_s = ~ /^to_(.*)/ वापसी पंक्तियाँ_ ($ 1.to_sym = & gt; args [0 ]) अगर id.to_s = ~ /^rows_with_(.*)/ सुपर अंत # ... अंत   
  प्रसंग:  
 Ruport एक रूबी है रिपोर्टिंग लाइब्रेरी उदाहरण के लिए: आप Ruport :: Data :: Table वर्ग को टैब्यूलर डेटा बनाने और उसे विभिन्न प्रारूपों में परिवर्तित कर सकते हैं उदाहरण के लिए:  
  'ruport' table = Ruport :: डेटा :: तालिका। नया: स्तंभ_नाम = & gt; ["देश", "शराब"],: डेटा = & gt; [["फ्रांस", "बॉर्डो"], ["इटली", "चीनिटी"], ["फ़्रांस", "चाब्लिस"]] टेबल डालता है। + -------------------- + + | देश | शराब | + -------------------- + + | फ़्रांस | बोर्डो | | इटली | चीयनती | | फ़्रांस | चाब्लिस | + -------------------- +   
 चलो कहना है कि आप केवल फ्रांसीसी वाइन का चयन करते हैं और उन्हें परिवर्तित करते हैं अल्पविराम से अलग किए गए मान:  <पूर्व>  पाया = तालिका। पंक्ति_विशेषताएं ("फ़्रांस") found.each do | row | Row.to_csv end को कहते हैं फ़्रांस, बोर्डो फ्रांस, चाब्लिस   
 आपने अभी क्या किया है, रोर्स्_विंडो () नाम की एक विधि को बुलाओ Ruport :: Data :: Table पर लेकिन इस क्लास के लेखक को कैसे पता था कि आपको देश नामक एक कॉलम होगा? तथ्य यह है, लेखक ने यह नहीं बताया कि। यदि आप रुपर्ट के अंदर देखते हैं, तो आप देखेंगे कि दोनों पंक्तियों_विशेष () और to_csv () हैं Ghost मेथोड्स। रुपर्ट :: डेटा :: तालिका वर्ग कुछ हद तक ऊपर वर्णित है।  
 पंक्तियों के साथ एक कॉल () एक अधिक परंपरागत दिखने वाली विधि के लिए कॉल बन जाता है, पंक्तियों के साथ (: देश), जो स्तंभ नाम को एक तर्क के रूप में लेता है इसके अलावा, to_csv () को कॉल (as: csv) के रूप में कॉल बन जाता है। यदि विधि का नाम इन दोनों उपसर्गों में से किसी के साथ प्रारंभ नहीं होता है, तो रुपर्ट कर्नेल # विधि_मिशन () पर वापस आ जाता है, जो एक नोड विधिएर्रर को फेंकता है (यह है कि सुपर खोजशब्द के लिए क्या है।)   
 
 
 चलिए  Method_missing :  
  def method_missing (आईडी, * आर्ग्स, और ब्लॉक) के रूप में वापसी ($ 1.to_sym, * args, और amp; ब्लॉक) id.to_s = ~ / ^ _ (। *) / रिटर्न पंक्तियों_with ($ 1.to_sym = & gt; आर्ग्स [0]) अगर आईडी.to_s = ~ /^rows_with_(.*)/ सुपर एंड   
 अपेक्षित पृष्ठभूमि :  method_missing  किसी ऑब्जेक्ट पर कॉल किया जाता है जब अनुरोधित विधि स्पष्ट रूप से परिभाषित नहीं होती है।  आईडी  नाम की विधि का प्रतीक होगा;  args  तर्कों की एक सरणी होगी, और  ब्लॉक  एक  Proc  होगा यदि कोई ब्लॉक था, या  शून्य ।  <पूर्व>  वापसी के रूप में ($ 1.to_sym, * args, और ब्लॉक) अगर आईडी.to_s = ~ /^to_(.*)/   
 निष्पादन वास्तव में अंत में शुरू होता है,  में : यह स्थिति की जांच करता है  
  id.to_s = ~ /to_(.*)/   
 यह मूल रूप से regexp का एक मेल करता है जिसे कहा जाता है कि विधि की स्ट्रिंग पर।  x = ~ y  पूर्णांक ऑफसेट को  x  में देता है जहां  y  मिलान होता है, यदि कहीं भी हो, अन्यथा शून्य उदा।:  
  & gt; "एबीसी" = ~ / ए / = & gt; 0 & gt; "एबीसी" = ~ /.$/ = & gt; 2 & gt; "Abc" = ~ / \ d / = & gt; शून्य   
 याद रखें कि  0  को बूलियन स्थितियों में सत्य माना जाता है, और इसलिए  अगर  केवल तभी सत्य माना जाता है अगर नामित फ़ंक्शन का नाम  से _  के साथ शुरू होता है। बाकी विधि नाम  (। *) ।  द्वारा कब्जा कर लिया गया है। अब, हम स्पष्ट रूप से कैप्चर समूहों को नहीं सहेजते हैं, लेकिन रूबी ने पर्ल से पहले कैप्चर में उधार लिया है समूह की सामग्री को  $ 1  में सहेजा जाएगा, दूसरा  $ 2 , आदि।:  
  & gt; "Abc" = ~ /a( .)(.)/ = & gt; 0 & gt; $ 1 = & gt; "बी" & gt; $ 2 = & gt; "C"   
 अब, वापस प्रश्न में पंक्ति में:  
  वापस आईडी के रूप में ($ 1.to_sym, * args, और ब्लॉक) अगर आईडी To_s = ~ /^to_(.*)/   
 इसलिए, यदि विधि का नाम फ़ॉर्म  to_XYZ  है, तो इसे  को कॉल करता है (जैसा कि )  विधि को : XYZ  पर सेट पहले तर्क के साथ, और कॉल से बाकी आर्गुमेंट जोड़े गए, और ब्लॉक (यदि कोई हो) के माध्यम से पार किया गया।  
 जारी रखने के लिए:  
  वापसी पंक्तियां_ ($ 1.to_sym = & gt; आर्ग्स [0]) अगर आईडी.to_s = ~ /^rows_with_(.*)/   
 यह मूल रूप से एक जैसा है: यदि विधि का नाम  rows_with_ABC  जैसा होता है, तो यह  पंक्तियों के साथ ()  एक हैश  {: ABC = & gt; अरग [0]} , जहां  आर्ग्स [0]  लापता विधि कॉल के लिए दिया गया पहला तर्क है।