मॉड्यूल `ClassMethods` को उसी नामस्थान में परिभाषित और विस्तारित क्यों किया गया?

Question

मैं github repo से कोड को समझने की कोशिश कर रहा हूं। यह ग्राहक स्थापित करने के लिए मणि का मुख्य मॉड्यूल है।

module Github 
    # more code 
    class << self 
    def included(base) 
     base.extend ClassMethods # what would this be for? 
    end 
    def new(options = {}, &block) 
     Client.new(options, &block) 
    end 
    def method_missing(method_name, *args, &block) 
     if new.respond_to?(method_name) 
     new.send(method_name, *args, &block) 
     elsif configuration.respond_to?(method_name) 
     Github.configuration.send(method_name, *args, &block) 
     else 
     super 
     end 
    end 
    def respond_to?(method_name, include_private = false) 
     new.respond_to?(method_name, include_private) || 
     configuration.respond_to?(method_name) || 
     super(method_name, include_private) 
    end 
    end 

    module ClassMethods 
    def require_all(prefix, *libs) 
     libs.each do |lib| 
     require "#{File.join(prefix, lib)}" 
     end 
    end 
    # more methods ... 
    end 

    extend ClassMethods 
    require_all LIBDIR, 
    'authorization', 
    'validations', 
    'normalizer', 
    'parameter_filter', 
    'api', 
    'client', 
    'pagination', 
    'request', 
    'response', 
    'response_wrapper', 
    'error', 
    'mime_type', 
    'page_links', 
    'paged_request', 
    'page_iterator', 
    'params_hash' 

end 

1. क्यों class << self और module ClassMethods इस्तेमाल किया है, और फिर class << self भाग में शामिल किए जाने के बजाय बढ़ा दिया?
2. कक्षा वर्ग def included(base) है। ऐसा लगता है कि वर्ग विधियों को एक विशिष्ट वस्तु में जोड़ना है। यह इस तरह क्यों है? यह कक्षा की कार्यक्षमता से संबंधित हो सकता है, लेकिन मुझे समझ में नहीं आता है।

Answer 1

module MyModule 
    class << self 
    def included(base) 
     base.extend ClassMethods # what would this be for? 
    end 
    <...> 
    end 
    <...> 
end 

यह वास्तव में रूबी में एक बहुत ही आम प्रथा है। असल में, यह क्या कह रहा है: जब कुछ ऑब्जेक्ट include MyModule करता है, तो इसे extend MyModule::ClassMethods भी बनाएं। इस तरह की उपलब्धि उपयोगी है यदि आप एक मिश्रण चाहते हैं जो कुछ वर्गों को केवल वर्ग के उदाहरणों के लिए ही नहीं, बल्कि वर्ग के लिए भी जोड़ता है।

एक छोटी उदाहरण:

module M 
    # A normal instance method 
    def mul 
    @x * @y 
    end 

    module ClassMethods 
    # A class method 
    def factory(x) 
     new(x, 2 * x) 
    end 
    end 

    def self.included(base) 
    base.extend ClassMethods 
    end 
end 

class P 
    include M 
    def initialize(x, y) 
    @x = x 
    @y = y 
    end 

    def sum 
    @x + @y 
    end 
end 

p1 = P.new(5, 15) 
puts "#{p1.sum} #{p1.mul}" 

# Calling the class method from the module here! 
p2 = P.factory(10) 
puts "#{p2.sum} #{p2.mul}" 

Answer 2

repo में और अधिक खोज रहे हैं वहाँ एक और वर्ग Github::API है। इस वर्ग को Github::ClassMethods मॉड्यूल की कार्यक्षमता की आवश्यकता होती है।

module Github 
    # Core class responsible for api interface operations 
    class API 
    extend Github::ClassMethods 

तो यह है कि यह स्वयं के मॉड्यूल के मालिक हैं है समझ में आता है। यह केवल उन तरीकों को आयात करने की क्षमता देता है। यदि class << self के तरीकों को शामिल किया गया था, तो वे उपलब्ध हो जाएंगे जो शायद नहीं चाहते थे।

मॉड्यूल को अपनी कक्षा में रखना या कुछ और नाम देना बेहतर हो सकता है। लेकिन मुझे लगता है कि यह सिर्फ व्यक्तिगत पसंद है।