Question

I have to add methods to Class in execution time.

class ExtendableClass
end

The methods to add are declared in independent Classes.

module ExtensionClassOne
  def method_one
  end
end

module ExtensionClassTwo
  def method_two
  end
end

I’m looking for an (elegant) mechanism to add all the extension class methods into the ExtendableClass.

Approach 1

I’m thinking in explicily include the extension classes like:

ExtendableClass.send( :include, ExtensionClassOne )
ExtendableClass.send( :include, ExtensionClassTwo )

but it looks a little forced to have to call this private method every time I define a new extension class.

Approach 2

So I was looking for an automatic way to include this methods into my ExtendableClass class.

I’m thinking in declare an specific ancestor for this extension classes:

class ExtensionClassOne < Extension
  def method_one
  end
end

and then I’d need a mechanism to know all the childs of a class… something like the oposite of ancestors.

Once I have this list I can easily ExtendableClass.include all the list of classes. Even if I have to call to the private method here.

Approach 3

Also inheriting from the Extension class and detect in declaration time when this class is used as ancestor. In the way that the ActiveSupport.included method works, like an event binding. Then make the include there.

Any solution for implement approach 2 or approach 3? Do you recommend approach 1? New approachs?

Answer 1

@fguillen, you are right that the “explicit way is the cleanest approach”. Since that is so, why don’t you use the most “explicit” code which could be imagined:

class Extendable
end

class Extendable
  def method_one
    puts "method one"
  end
end

class Extendable
  def method_two
    puts "method two"
  end
end

…In other words, if you are defining a module which will be automatically included in a class as soon as it is defined, why bother with the module at all? Just add your “extension” methods directly to the class!