calling method on base intended to simulate initialize on instances?

class A
  def initialize

  def b_and_c
   "#{@b} and #{@c}"

def setup_b
    @b = 'b'

  def setup_c
    @c = 'c'

  def setup_d
    @d = 'd'

a =
a.instance_variable_get("@b") # => "b"
a.instance_variable_get("@c") # => "c"
a.instance_variable_get("@d") # => nil
a = # => "b and c"

Now what I did above is to make a point. initialize allows us to
create some initial setup for new objects, so that when we call a
public method like b_and_c, we can expect certain values back based on
the initialization hook that must occur first. From my understanding,
modules do not have an initialize method, so then how do you simulate
it? Well, I was looking at Rails and notice this:

class Template
    module Handlers
      autoload :ERB, 'action_view/template/handlers/erb'
      autoload :Builder, 'action_view/template/handlers/builder'
      autoload :Raw, 'action_view/template/handlers/raw'

      def self.extended(base)
        base.register_default_template_handler :erb,
        base.register_template_handler :builder,
        base.register_template_handler :raw,

      @@template_handlers = {}
      @@default_template_handlers = nil

      def self.extensions
        @@template_extensions ||= @@template_handlers.keys

      def register_default_template_handler(extension, klass)
        register_template_handler(extension, klass)
        @@default_template_handlers = klass

     def register_template_handler(extension, handler)
        @@template_handlers[extension.to_sym] = handler
        @@template_extensions = nil

class Template
    extend Template::Handlers

class LookupContext
   register_detail(:handlers){ Template::Handlers.extensions }

Basically, when ruby loads the Template class (I will assume that it
must be loaded prior to Handlers module or LookupContext class), it
immediately executes a class method, which is called extend, and
passes the module Handlers as the lone argument. What the extend
method does is copy the methods of the module Handlers to the Template
class as class methods. But what else happens is the self.extended
hook is immediately triggered, just as initialize is when you
instantiate a class. We pass our Template class object as the
parameter base. And we call the register_default_template_handler
method (which is now a class method of Template), passing it a
symbol :erb and an instance of ERB, which returns a string from
call(). We in turn call register_template_handler, passing in the same
two arguments. We simply append the key/value pair to the
@@template_handlers class variable, which is a hash data type, and
allows us to add a number of key/value pairs corresponding to
extensions and template types. (e.g. :erb extension corresponding to
an ERB template type). Hence, when we invoke the module method
extensions on the module, it can return a value for the
@@template_handlers class variable, since it was initialized with
values during the hook, prior to the extensions method call.

I have a few questions about this.

1) Is is true to say that the class variables of the module get
initialized prior than the extended hook. Reason why say this is that
the extended hook calls a method that expects the variable to be set

2) Do all the methods of the module get copied over to base (Template
class object) prior to the hook being called? Reason why I say this is
because we call base.register_default_template_handler, where base is
Tempalte object an register_default_template_handler is defined in the
module that gets copied to base as a class method via extend. Hence,
in order for base.register_default_template_handler to work, the
methods must have been copied first.

3) Can anyone tell me what @@template_extensions is for? I dont see
that initialized with a value anywhere other than nil.

thanks for response


class Dog
  module Cat
    puts 'hello'



Do all the methods of the module get copied over to base


3) I don't know.