Ruby Language
Módulos

Sintaxis

• Declaración

  module Name;
  
      any ruby expressions;
  
  end
  

Observaciones

module foo; end # Syntax error: class/module name must be CONSTANT

Una mezcla simple con incluir

module SomeMixin
  def foo
    puts "foo!"
  end
end

class Bar
  include SomeMixin
  def baz
    puts "baz!"
  end
end

b = Bar.new
b.baz         # => "baz!"
b.foo         # => "foo!"
# works thanks to the mixin

Ahora Bar es una mezcla de sus propios métodos y los métodos de SomeMixin .

Tenga en cuenta que la forma en que se utiliza una mezcla en una clase depende de cómo se agrega:

• la palabra clave include evalúa el código del módulo en el contexto de la clase (por ejemplo, las definiciones de métodos serán métodos en instancias de la clase),
• extend evaluará el código del módulo en el contexto de la clase singleton del objeto (los métodos están disponibles directamente en el objeto extendido).

Módulo como espacio de nombres

Los módulos pueden contener otros módulos y clases:

module Namespace

    module Child

        class Foo; end

    end # module Child

    # Foo can now be accessed as:
    #
    Child::Foo

end # module Namespace

# Foo must now be accessed as:
# 
Namespace::Child::Foo

Una mezcla simple con extender

Un mixin es solo un módulo que se puede agregar (mezclar) a una clase. Una forma de hacerlo es con el método extendido. El método de extend agrega métodos de la mezcla como métodos de clase.

module SomeMixin
  def foo
    puts "foo!"
  end
end

class Bar
  extend SomeMixin
  def baz
    puts "baz!"
  end
end

b = Bar.new
b.baz         # => "baz!"
b.foo         # NoMethodError, as the method was NOT added to the instance
Bar.foo       # => "foo!"
# works only on the class itself 

Módulos y composición de clase

Puedes usar módulos para construir clases más complejas a través de la composición . La directiva include ModuleName incorpora los métodos de un módulo en una clase.

module Foo
  def foo_method
    puts 'foo_method called!'
  end
end

module Bar
  def bar_method
    puts 'bar_method called!'
  end
end

class Baz
  include Foo
  include Bar

  def baz_method
    puts 'baz_method called!'
  end  
end

Baz ahora contiene métodos tanto de Foo como de Bar además de sus propios métodos.

new_baz = Baz.new
new_baz.baz_method #=> 'baz_method called!'
new_baz.bar_method #=> 'bar_method called!'
new_baz.foo_method #=> 'foo_method called!'