rails - type variable ruby

¿Por qué el módulo `ClassMethods` definido y extendido en el mismo espacio de nombres?

Question

Estoy tratando de entender el código de github repo . Es el módulo principal de la gema para configurar el cliente.

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. ¿Por qué se utiliza class << self y el module ClassMethods , y luego se extiende en lugar de ser incluido en la class << self part?
2. Hay un método de clase def included(base) . Esto parece agregar los métodos de clase en un objeto específico. ¿Por qué es como este? Podría estar relacionado con la funcionalidad de la clase, pero no lo entiendo.

Answer 1

Mirando más en el repo hay otra clase Github::API . Esta clase parece requerir la funcionalidad del módulo Github::ClassMethods .

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

Así que tiene sentido que sea su propio módulo. Da la posibilidad de importar solo esos métodos. Si se incluyeran los métodos de la class << self , estarían disponibles, lo que probablemente no se desee.

Es posible que haya sido mejor tener el módulo en su propia clase o que haya nombrado otra cosa. Pero supongo que es solo una elección personal.

Answer 2

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

Esta es en realidad una práctica bastante común en Ruby. Básicamente, lo que dice es: cuando se realiza algún objeto include MyModule , haz que también extend MyModule::ClassMethods . Tal hazaña es útil si desea una combinación que agregue algunos métodos no solo a las instancias de una clase, sino a la clase en sí.

Un breve ejemplo:

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}"