For Class, Module#class_extend is similar to class_eval.
The alternative is to “undef_method :#class_extend”, but this seems uneccessarily limited.
# File lib/core-uncommon/facets/module/class_extend.rb, line 77 def class_extend(*mods, &block) class_extension = Module.new class_extension.__send__(:include, *mods) class_extension.module_eval(&block) if block extend(class_extension) class_extensions << class_extension end
List all descedents of this class.
class A ; end class B < A; end class C < A; end A.descendants #=> [B,C]
You may also limit the generational distance the subclass may be from the parent class.
class X ; end class Y < X; end class Z < Y; end X.descendants #=> [Y,Z] X.descendants(1) #=> [Y]
NOTE: This is a intensive operation. Do not expect it to be very fast.
# File lib/core/facets/class/descendants.rb, line 23 def descendants(generations=-1) descendants = [] subclasses.each do |k| descendants << k if generations != 1 descendants.concat(k.descendants(generations - 1)) end end descendants end
Translate a class name to a suitable method name.
module ::Example class MethodizeExample end end Example::MethodizeExample.methodize #=> "example__methodize_example"
# File lib/core/facets/class/methodize.rb, line 14 def methodize name.methodize end
Converts a class name to a unix path.
module ::Example class PathizeExample end end Example::PathizeExample.pathize #=> "example/pathize_example"
# File lib/core/facets/class/pathize.rb, line 14 def pathize name.pathize end
Designate aspect modules to be added to a object at instantiation.
class Firetruck def put_out_fire(option) "Put out #{option}" end end module FastFiretruck def put_out_fire(option) super("very #{option}!") end end Firetruck.preallocate(FastFiretruck) ft = Firetruck.new ft.put_out_fire('fast') #=> "Put out very fast!"
This method is very similar to the idea of prepend, but it has some limitations in that it works by overriding new and allocate and extends an object with the aspect modules on instantiation. A true prepend implementation would not have to do this –but would be a natural part of the class heirarchy instead. For this reason, this method has been named #preallocate, rather than prepend.
NOTE: This is not (presently) a common core extension and is not loaded
automatically when using require 'facets'
.
CREDIT: Trans
# File lib/core-uncommon/facets/class/preallocate.rb, line 34 def preallocate(aspect) _new = method(:new) _allocate = method(:allocate) (class << self; self; end).class_eval do define_method(:new) do |*args| o = _new.call(*args) o.extend aspect o end define_method(:allocate) do |*args| o = _allocate.call(*args) o.extend aspect o end end end
Returns an array with the direct children of self
.
Integer.subclasses # => [Fixnum, Bignum]
# File lib/core/facets/class/subclasses.rb, line 17 def subclasses list = [] ObjectSpace.each_object(Class) do |c| list.unshift c if c.superclass == self end list.uniq end
Convert instatiation of a class into a Proc.
class Person def initialize(name) @name = name end def inspect @name.to_str end end persons = %W(john bob jane hans).map(&Person) persons.map{ |p| p.inspect } #=> ['john', 'bob', 'jane', 'hans']
CREDIT: Daniel Schierbeck
# File lib/core/facets/class/to_proc.rb, line 20 def to_proc proc{|*args| new(*args)} end