Ruby Language
Modules

Syntaxe

• Déclaration

  module Name;
  
      any ruby expressions;
  
  end
  

Remarques

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

Un mixin simple avec include

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

Maintenant, Bar est un mélange de ses propres méthodes et des méthodes de SomeMixin .

Notez que la façon dont un mixin est utilisé dans une classe dépend de la manière dont il est ajouté:

• le mot include clé include évalue le code du module dans le contexte de la classe (par exemple, les définitions de méthode seront des méthodes sur les instances de la classe),
• extend évalue le code du module dans le contexte de la classe singleton de l'objet (les méthodes sont disponibles directement sur l'objet étendu).

Module comme espace de noms

Les modules peuvent contenir d'autres modules et classes:

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

Un mixin simple avec extension

Un mixin est juste un module qui peut être ajouté à une classe. une façon de le faire est avec la méthode d'extension. La méthode extend ajoute des méthodes de mixin en tant que méthodes de classe.

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 

Composition des modules et des classes

Vous pouvez utiliser des modules pour créer des classes plus complexes via la composition . La directive include ModuleName incorpore les méthodes d'un module dans une classe.

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 contient désormais des méthodes provenant de Foo et de Bar en plus de ses propres méthodes.

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!'