Appendix A - Glossary - Rubinius
Author: Less Than Three. <3. http://less.thanthree.com
Description: Rubinius is an implementation of the Ruby programming language. The Rubinius bytecode virtual machine is written in C++. The bytecode compiler is written in pure Ruby. The vast majority of the core library is also written in Ruby, with some supporting primitives that interact with the VM directly.

1.2.3

## Appendix A - Glossary

This page was machine translated. Please help us improve it.

See How-To - Translate Documentation

This topic has missing or partial documentation. Please help us improve it.

See How-To - Write Documentation

Definitions of terms and phrases used in the Ruby programming language and in this implementation. See also “The Ruby Programming Language” by Flanagan and Matsumoto [O’Reilly 2008] and “Programming Ruby: The Pragmatic Programmer’s Guide” 2nd or 3rd Edition by Thomas et al [The Pragmatic Programmers 2005-2008]

- method lookup or method resolution

  The rule is simple: Take the object located in the class slot of the object (which is not always the return value of Object#class; if the object has one, it’ll be the singleton class) and begin searching.

  Searching goes up the superclass chain until the superclass is nil.

  In which case, redo lookup for method_missing. If we fail to find method_missing, fail tragically.

                                            +----------------+
                                            |      nil       |
                                            +----------------+
                                                    ^
                                                    | superclass
                                                    |
                                            +----------------+
                                            |     Object     |
                                            +----------------+
                                                    ^
                                                    | superclass
                                                    |
                                            +----------------+
                                            |     Module     |
                                            +----------------+
                                                    ^
                                                    | superclass
                                                    |
                                            +----------------+
                                            |     Class      |
                                            +----------------+
                                                    ^
                                                    | superclass
                                                    |
                                            +----------------+
                                            | SingletonClass |
                                            |    (Object)    |
                                            +----------------+
                                                    ^
                                                    | superclass
                                                    |
       +-------------+                      +----------------+
       |      F      |  ----------------->  | SingletonClass |
       +-------------+   singleton class    |      (F)       |
                                            +----------------+

      class Class
        def wanker
          puts 'you are'
        end
      end

      class F
        def self.bloke
          wanker
        end
      end

  1. Resolve method ‘wanker’ – search method_tables in:

     1. SingletonClass(F)
     2. SingletonClass(Object)
     3. Class

  Found

- method_table

  A data structure in every class (and module) that contains the methods defined for that class.

  In Rubinius, a class’s method_table is an instance of LookupTable.

- MatzRuby

  See MRI

- MRI

  Matz’s Ruby Interpreter or Matz’s Ruby Implementation. A short name to refer to the official implementation of Ruby. See http://ruby-lang.org.

- private send

  A method call that has no explicit lexical receiver. The receiver of the call is +self+. For example:

      class A
      private
        def you_are_mine
        end
      end

      class B < A
        def sunshine
          you_are_mine
        end
      end

      class C
        def dear
          today = B.new
          today.you_are_mine
        end
      end

  The call to +you_are_mine+ in the method +sunshine+ is a private send. The call to +today.you_are_mine+ will not succeed because private methods cannot have an explicit receiver. In this case, the object +today+ is the explicit receiver.

- singleton class

  Every object in Ruby can have one, although they are only created as necessary. The singleton class holds the method and constant tables that belong only to a particular object instance. For example, the method +hello+ defined below exists only in the singleton class for +obj+.

      obj = Object.new
      def obj.hello
        puts 'hi'
      end

  Since all classes in Ruby are also objects, they can have singleton classes. The methods called “class methods” are just methods in the method_table of the class’s singleton class. The method +honk+ exists in the singleton class for the class +Car+.

      class Car
        def self.honk
        end
      end

  In Rubinius, singleton classes are all instances of the class SingletonClass. The singleton class for an object can be obtained by calling the +singleton_class+ method. The overall arrangement of concepts involved here is sometimes referred to as the ‘Meta-Object Protocol’ or +MOP+.

- superclass

  The class that a particular class immediately inherits from. The class Object is the superclass of all classes that do not inherit explicitly from a class.

      class A
      end

      class B < A
      end

  Class A inherits from Object. In other words, A.superclass == Object. Class B inherits explicitly from class A. So, B.superclass == A.