Just getting my head around Ruby metaprogramming. The mixin/modules always manage to confuse me.
So is the major difference just this or is a bigger dragon lurking? e.g.
module ReusableModule
def module_method
puts "Module Method: Hi there!"
end
end
class ClassThatIncludes
include ReusableModule
end
class ClassThatExtends
extend ReusableModule
end
puts "Include"
ClassThatIncludes.new.module_method # "Module Method: Hi there!"
puts "Extend"
ClassThatExtends.module_method # "Module Method: Hi there!"
extend - adds the specified module's methods and constants to the target's metaclass (i.e. the singleton class) e.g.
Klazz.extend(Mod)
, now Klazz has Mod's methods (as class methods)obj.extend(Mod)
, now obj has Mod's methods (as instance methods), but no other instance of of obj.class
has those methods added.extend
is a public methodinclude - By default, it mixes in the specified module's methods as instance methods in the target module/class. e.g.
class Klazz; include Mod; end;
, now all instances of Klazz have access to Mod's methods (as instance methods)include
is a private method, because it's intended to be called from within the container class/module.However, modules very often override include
's behavior by monkey-patching the included
method. This is very prominent in legacy Rails code. more details from Yehuda Katz.
Further details about include
, with its default behavior, assuming you've run the following code
class Klazz
include Mod
end
@@foo
or @@bar
super
in Klazz#foo will check for Mod#foo before checking to Klazz's real superclass's foo method. See the RubySpec for details.).Of course, the ruby core documentation is always the best place to go for these things. The RubySpec project was also a fantastic resource, because they documented the functionality precisely.