For Class, Module#class_extend is similar to class_eval.

The alternative is to "undef_method :class_extend", but this seems uneccessarily limited.

@uncommon

  require 'facets/module/class_extend'

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.

@author Roger Pack

Translate a class name to a suitable method name.

  module ::Example
    class MethodizeExample
    end
  end

  Example::MethodizeExample.methodize  #=> "example__methodize_example"

Converts a class name to a unix path.

  module ::Example
    class PathizeExample
    end
  end

  Example::PathizeExample.pathize  #=> "example/pathize_example"

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 method is not a common core extension and is not loaded automatically when using require ‘facets‘.

CREDIT: Trans

@uncommon

  require 'facets/class/preallocate'

Alias for singleton_class?

Return true if a class is the singleton class of an object.

@uncommon

  require 'facets/class/singleton_class'

Returns an array with the direct children of self.

  Integer.subclasses # => [Fixnum, Bignum]

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