kernel/core/class.rb

   1 # depends on: object.rb
   2
   3 ##
   4 # Classes in Ruby are first-class objects, each is an instance of
   5 # class Class.
   6 #
   7 # When a new class is created (typically using <tt>class Name; ... end</tt>),
   8 # an object of type Class is created and assigned to a global constant (Name
   9 # in this case). When <tt>Name.new</tt> is called to create a new object, the
  10 # new method in Class is run by default.
  11 #
  12 # This can be demonstrated by overriding new in Class:
  13 #
  14 #   class Class
  15 #     alias old_new new
  16 #     def new(*args)
  17 #       puts "Creating a new #{self.name}"
  18 #       old_new(*args)
  19 #     end
  20 #   end
  21 #
  22 #   class Name
  23 #   end
  24 #
  25 #   n = Name.new
  26 #
  27 # *produces:*
  28 #
  29 #   Creating a new Name
  30 #
  31 # Classes, modules, and objects are interrelated. In the diagram that follows,
  32 # the vertical arrows represent inheritance, and the parentheses meta-classes.
  33 # All metaclasses are instances of the class Class.
  34 #
  35 #                            +------------------+
  36 #                            |                  |
  37 #              Object---->(Object)              |
  38 #               ^  ^        ^  ^                |
  39 #               |  |        |  |                |
  40 #               |  |  +-----+  +---------+      |
  41 #               |  |  |                  |      |
  42 #               |  +-----------+         |      |
  43 #               |     |        |         |      |
  44 #        +------+     |     Module--->(Module)  |
  45 #        |            |        ^         ^      |
  46 #   OtherClass-->(OtherClass)  |         |      |
  47 #                              |         |      |
  48 #                            Class---->(Class)  |
  49 #                              ^                |
  50 #                              |                |
  51 #                              +----------------+
  52
  53 class Class
  54
  55   protected :object_type
  56   protected :has_ivars
  57   protected :needs_cleanup
  58
  59   def initialize(sclass=Object)
  60     unless sclass.kind_of?(Class)
  61       raise TypeError, "superclass must be a Class (#{sclass.class} given)"
  62     end
  63
  64     @instance_fields = sclass.instance_fields
  65     @has_ivar = sclass.has_ivars
  66     @needs_cleanup = sclass.needs_cleanup
  67     @object_type = sclass.object_type
  68     @superclass = sclass
  69
  70     super()
  71
  72     mc = self.metaclass
  73     mc.set_superclass sclass.metaclass
  74
  75     block = block_given?
  76     class_eval(&block) if block
  77     # add class to sclass's subclass list, for ObjectSpace.each_object(Class)
  78     # NOTE: This is non-standard; Ruby does not normally track subclasses
  79     sclass.__send__ :inherited, self
  80   end
  81
  82   def opened_class_cv(cls)
  83     cls = Object unless cls
  84     cls.add_subclass(self)
  85
  86     cls.send :inherited, self
  87
  88     self # FIXME: hook calls should preserve the stack
  89   end
  90
  91   ##
  92   #--
  93   # NOTE: This method is not standard Ruby; JRuby implements it, but not
  94   # public
  95   #++
  96
  97   def add_subclass_cv(cls)
  98     @subclasses ||= []
  99     @subclasses << cls
 100   end
 101
 102   ##
 103   #--
 104   # NOTE: This method is not standard Ruby; JRuby implements it, but not
 105   # public
 106   #++
 107
 108   def subclasses_cv(descend = false)
 109     if descend
 110       subclasses_descend()
 111     elsif @subclasses
 112       @subclasses.dup
 113     else
 114       []
 115     end
 116   end
 117
 118   def subclasses_descend(all = [])
 119     return unless @subclasses
 120     @subclasses.each {|cls| all << cls; cls.subclasses_descend(all)}
 121     all
 122   end
 123
 124   ##
 125   # Returns the Class object that this Class inherits from. Included Modules
 126   # are not considered for this purpose.
 127
 128   def superclass()
 129     cls = direct_superclass
 130     return nil unless cls
 131     while cls and cls.kind_of? IncludedModule
 132       cls = cls.direct_superclass
 133     end
 134     return cls
 135   end
 136
 137   def inherited(name)
 138   end
 139
 140   def self.after_loaded
 141     alias_method :opened_class, :opened_class_cv
 142     alias_method :add_subclass, :add_subclass_cv
 143     alias_method :__subclasses__, :subclasses_cv
 144   end
 145 end
 146
 147 class MetaClass
 148
 149   ivar_as_index :superclass => 6
 150
 151   ##
 152   # Called when <tt>def obj.name</tt> syntax is used in userland
 153
 154   def attach_method(name, object)
 155     # All userland added methods start out with a serial of 1.
 156     object.serial = 1
 157
 158     cur = method_table[name]
 159     if cur and cur.kind_of? Tuple
 160       # Override the slot which points to the method, so that we
 161       # retain visibility.
 162       cur[1] = object
 163     else
 164       method_table[name] = Tuple[:public, object]
 165     end
 166
 167     object.inherit_scope MethodContext.current.sender.method
 168     Rubinius::VM.reset_method_cache(name)
 169
 170     # Call singleton_method_added on the object in question. There is
 171     # a default version in Kernel which does nothing, so we can always
 172     # call this.
 173     attached_instance.__send__ :singleton_method_added, name
 174
 175     return object
 176   end
 177
 178   def set_superclass(obj)
 179     @superclass = obj
 180   end
 181
 182   def inspect
 183     "#<MetaClass #{attached_instance.inspect}>"
 184   end
 185 end