Apéndice A - Glosario - 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

## Apéndice A - Glosario

Definición de términos y frases usadas en el lenguaje de programación Ruby y en esta implementación. Vea también “The Ruby Programming Language” por Flanagan y Matsumoto [O’Reilly 2008] y “Programming Ruby: The Pragmatic Programmer’s Guide” segunda o tercera edición por Thomas et al [The Pragmatic Programmers 2005-2008].

- method lookup or method resolution (búsqueda de métodos o resolución de métodos)

  La regla para la resolución de métodos es sencilla: Se toma el objeto que se encuentra en la posición class del objeto (que no siempre es igual a Object#class) y se comienza la búsqueda del método.

  La búsqueda se hace subiendo de niveles en la cadena de superclases hasta que el valor de superclass sea nil.

  Si superclass es nil se vuelve a comenzar la búsqueda tratando de hallar method_missing. Si no se encuentra method_missing se genera un error.

                                            +----------------+
                                            |      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. Para la resolución del método ‘wanker’ se hace la búsqueda en las method_tables de:

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

  Encontrado.

- method_table (tabla de métodos)

  Una estructura de datos hallada en todas las clases (y módulos) que contiene los métodos definidos para esa clase.

  En Rubinius la clase de method_table es una instancia de LookupTable.

- MatzRuby

  Ver MRI.

- MRI

  “Matz’s Ruby Interpreter” o “Matz’s Ruby Implementation”. Una abreviación para referirse a la implementación oficial de Ruby. Ver http://ruby-lang.org.

- private send (send privado)

  Una llamada de método que no tiene un receptor léxico explícito. El receptor en este caso es +self+. Ejemplo:

      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

  La llamada a +you_are_mine+ en el método +sunshine+ es un send privado. La llamada a +today.you_are_mine+ no funcionará ya que los métodos privados no pueden tener un receptor explícito. En el caso anterior +today+ sería el receptor explícito.

- singleton class (metaclase)

  Cualquier objeto en Ruby puede tener una aunque solamente son creadas cuando es necesario. La singleton clase tiene las tablas de métodos y constantes que preñen a una instancia (objeto) en particular. Por ejemplo, el método +hello+ definido a continuación existe solamente en la singleton clase de +obj+.

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

  Ya que las clases en Ruby también son objetos, estas pueden tener singleton clases. Los métodos de clase (class methods) son simplemente métodos en la tabla de métodos de la singleton clase de la clase. El método +honk+ existe en la singleton clase de la clase +Car+.

      class Car
        def self.honk
        end
      end

  Todas las singleton clases en Rubinius son instancias de la clase SingletonClass. La singleton clase para un objeto puede ser obtenida llamando al método +singleton_class+. Los conceptos mencionados aquí se conocen como el ‘Meta-Object Protocol’ o +MOP+.

- superclass (superclase)

  La clase de la cual una clase en particular hereda. La clase Object es la superclase de todas las clases que no heredan explícitamente de una clase.

      class A
      end

      class B < A
      end

  La clase A hereda de Object. En otras palabras, A.superclass == Object. La clase B hereda explícitamente de la clase A, así que B.superclass = A.