Rubí (lenguaje de programación)

Ruby es un lenguaje de programación interpretado, de alto nivel y de propósito general que admite múltiples paradigmas de programación. Fue diseñado con énfasis en la productividad y la simplicidad de la programación. En Ruby, todo es un objeto, incluidos los tipos de datos primitivos. Fue desarrollado a mediados de la década de 1990 por Yukihiro "Matz" Matsumoto en Japón.

Ruby se tipifica dinámicamente y utiliza recolección de elementos no utilizados y compilación justo a tiempo. Admite múltiples paradigmas de programación, incluida la programación procedimental, orientada a objetos y funcional. Según el creador, Ruby fue influenciado por Perl, Smalltalk, Eiffel, Ada, BASIC, Java y Lisp.

Historia

Concepto inicial

Matsumoto ha dicho que Ruby se concibió en 1993. En una publicación de 1999 en la lista de correo ruby-talk, describe algunas de sus primeras ideas sobre el lenguaje:

Estaba hablando con mi colega sobre la posibilidad de un lenguaje de escritura orientado al objeto. Conocí a Perl (Perl4, no Perl5), pero no me gustó mucho, porque tenía el olor de un lenguaje de juguete (todavía tiene). El lenguaje orientado al objeto parecía muy prometedor. Entonces conocí a Python. Pero no me gustó, porque no creía que fuera un verdadero lenguaje orientado al objeto – las características de OO parecían ser agregadas al lenguaje. Como fan de lenguaje maníaco y OO durante 15 años, realmente quería un auténtico lenguaje de scripting orientado al objeto, fácil de usar. Busqué pero no pude encontrar uno. Así que decidí hacerlo.

Matsumoto describe el diseño de Ruby como un simple lenguaje Lisp en su núcleo, con un sistema de objetos como el de Smalltalk, bloques inspirados en funciones de orden superior y una utilidad práctica como la de Perl.

El nombre "Rubí" se originó durante una sesión de chat en línea entre Matsumoto y Keiju Ishitsuka el 24 de febrero de 1993, antes de que se escribiera ningún código para el lenguaje. Inicialmente se propusieron dos nombres: "Coral" y "Rubí". Matsumoto eligió este último en un correo electrónico posterior a Ishitsuka. Más tarde, Matsumoto notó un factor en la elección del nombre "Ruby" – era la piedra de nacimiento de uno de sus colegas.

Lanzamientos anticipados

El primer lanzamiento público de Ruby 0.95 se anunció en grupos de noticias nacionales japoneses el 21 de diciembre de 1995. Posteriormente, se lanzaron tres versiones más de Ruby en dos días. El lanzamiento coincidió con el lanzamiento de la lista de correo ruby-list en japonés, que fue la primera lista de correo para el nuevo idioma.

En esta etapa de desarrollo ya estaban presentes muchas de las funciones familiares en versiones posteriores de Ruby, incluido el diseño orientado a objetos, clases con herencia, mixins, iteradores, cierres, manejo de excepciones y recolección de elementos no utilizados.

Tras el lanzamiento de Ruby 0.95 en 1995, se lanzaron varias versiones estables de Ruby en los años siguientes:

• Ruby 1.0: 25 de diciembre de 1996
• Ruby 1.2: diciembre de 1998
• Ruby 1.4: agosto de 1999
• Ruby 1.6: septiembre de 2000

En 1997, se publicó en la Web el primer artículo sobre Ruby. En el mismo año, netlab.jp contrató a Matsumoto para trabajar en Ruby como desarrollador a tiempo completo.

En 1998, Matsumoto lanzó Ruby Application Archive, junto con una sencilla página de inicio en inglés para Ruby.

En 1999, comenzó la primera lista de correo en inglés ruby-talk, lo que indicó un creciente interés en el idioma fuera de Japón. En este mismo año, Matsumoto y Keiju Ishitsuka escribieron el primer libro sobre Ruby, The Object-oriented Scripting Language Ruby (オブジェクト指向スクリプト言語 Ruby), que se publicó en Japón en octubre de 1999. Sería seguido a principios de la década de 2000 por alrededor de 20 libros sobre Ruby publicados en japonés.

Para el año 2000, Ruby era más popular que Python en Japón. En septiembre de 2000, se imprimió el primer libro en inglés Programming Ruby, que más tarde se lanzó gratuitamente al público, ampliando aún más la adopción de Ruby entre los angloparlantes. A principios de 2002, la lista de correo ruby-talk en inglés recibía más mensajes que la ruby-list en japonés, lo que demuestra la creciente popularidad de Ruby en el mundo de habla no japonesa.

Rubí 1.8 y 1.9

Ruby 1.8 se lanzó inicialmente en agosto de 2003, se mantuvo estable durante mucho tiempo y se retiró en junio de 2013. Aunque está en desuso, todavía hay código basado en él. Ruby 1.8 solo es parcialmente compatible con Ruby 1.9.

Ruby 1.8 ha sido objeto de varios estándares de la industria. Las especificaciones de idioma para Ruby fueron desarrolladas por el Centro de Promoción de Estándares Abiertos de la Agencia de Promoción de Tecnologías de la Información (una agencia del gobierno japonés) para enviarlas al Comité Japonés de Estándares Industriales (JISC) y luego a la Organización Internacional de Normalización (ISO). Fue aceptado como estándar industrial japonés (JIS X 3017) en 2011 y estándar internacional (ISO/IEC 30170) en 2012.

Alrededor de 2005, el interés por el lenguaje Ruby aumentó junto con Ruby on Rails, un marco web escrito en Ruby. A Rails se le atribuye con frecuencia el aumento de la conciencia de Ruby.

Efectivo con Ruby 1.9.3, lanzado el 31 de octubre de 2011, Ruby pasó de tener una licencia doble bajo la Licencia Ruby y la GPL a una licencia doble bajo la Licencia Ruby y la licencia BSD de dos cláusulas. La adopción de 1.9 se vio ralentizada por los cambios de 1.8 que requirieron que se reescribieran muchas gemas populares de terceros. Ruby 1.9 introduce muchos cambios significativos sobre la serie 1.8. Ejemplos incluyen:

• bloque de variables locales (variables que son locales al bloque en el que se declaran)
• una sintaxis de lambda adicional: f = ->(a,b) { puts a + b }
• una sintaxis literal Hash adicional usando colones para las teclas de símbolo: {symbol_key: "value"} == {:symbol_key => "value"}
• codificaciones de caracteres por anillo son compatibles
• nueva API de socket (apoyo IPv6)
• require_relative Seguridad de las importaciones

Rubí 2

Ruby 2.0 estaba destinado a ser totalmente compatible con versiones anteriores de Ruby 1.9.3. A partir del lanzamiento oficial de 2.0.0 el 24 de febrero de 2013, solo había cinco incompatibilidades (menores) conocidas. Ruby 2.0 agregó varias características nuevas, que incluyen:

• método keyword arguments,
• un nuevo método, Module#prepend, para extender una clase,
• un nuevo literal para crear un array de símbolos,
• nueva API para la evaluación perezosa de Enumerables, y
• una nueva convención de usar #to_h para convertir objetos a Hashes.

A partir de la versión 2.1.0, la política de control de versiones de Ruby cambió para parecerse más al control de versiones semántico.

Ruby 2.2.0 incluye mejoras de velocidad, correcciones de errores y actualizaciones de la biblioteca y elimina algunas API obsoletas. En particular, Ruby 2.2.0 introduce cambios en el manejo de la memoria: un recolector de basura incremental, compatibilidad con la recolección de basura de símbolos y la opción de compilar directamente contra jemalloc. También contiene soporte experimental para usar vfork(2) con system() y spawn(), y soporte adicional para la especificación Unicode 7.0. Desde la versión 2.2.1, se mejoró el rendimiento de Ruby MRI en PowerPC64. Las funciones que quedaron obsoletas o eliminadas incluyen callcc, la biblioteca DL, Digest::HMAC, lib/rational.rb, lib/complex.rb, GServer, Logger::Application, así como varias funciones de la API de C.

Ruby 2.3.0 incluye muchas mejoras de rendimiento, actualizaciones y correcciones de errores, incluidos cambios en Proc#call, uso de Socket y IO de palabras clave de excepción, manejo de Thread#name, conexiones Net::FTP pasivas predeterminadas y Rake que se elimina de stdlib. Otros cambios notables incluyen:

• La capacidad de marcar todos los literales de cadena como congelado por defecto con un aumento de rendimiento en las operaciones de cadenas.
• Comparación de malla para permitir la comprobación directa de pares de clave/valor en lugar de llaves justas.
• Un nuevo operador de navegación seguro &. que puede facilitar el manejo de nil (por ejemplo, en lugar de if obj && obj.foo && obj.foo.bar, podemos usar if obj&.foo&.bar).
• El ¿Qué? gem ahora se agrupa por defecto y se requiere en el inicio para sugerir automáticamente coincidencias de nombre similares en un NameError o NoMethodError.
• Hash#dig y Array#dig para extraer fácilmente valores anidados (por ejemplo, dados profile = { social: { wikipedia: { name: 'Foo Baz' } } }, el valor Foo Baz puede ser recuperado por profile.dig(:social,:wikipedia,:name)).
• .grep_v(regexp) que coincidirá con todos los ejemplos negativos de una expresión regular dada, además de otras nuevas características.

Ruby 2.4.0 incluye mejoras de rendimiento en la tabla hash, Array#max, Array#min y acceso a variables de instancia. Otros cambios notables incluyen:

• Binding#irb: Iniciar una sesión de REPL similar a la unión. pry
• Unificar Fixnum y Bignum en Integer clase
• Soportes de cuerda Cartografías de casos Unicode, no sólo ASCII
• Un nuevo método, Regexp#match?, que es una versión booleana más rápida de Regexp#match
• Thread deadlock detección ahora muestra hilos con su backtrace y dependencia

Algunos cambios notables en Ruby 2.5.0 incluyen declaraciones rescue y ensure que usan automáticamente un bloque do-end circundante (menos necesidad de bloques extra begin-end), encadenamiento de métodos con yield_self, soporte para cobertura de ramas y medición de cobertura de métodos, y transformaciones Hash más sencillas con Hash#slice y Hash#transform_keys Además de eso, vienen muchas mejoras de rendimiento, como un paso de bloques más rápido (3 veces más rápido), Mutexes más rápidos, plantillas ERB más rápidas y mejoras en algunos métodos de concatenación.

Algunos cambios notables en Ruby 2.6.0 incluyen un compilador justo a tiempo (JIT) experimental y RubyVM::AbstractSyntaxTree (experimental).

Algunos cambios notables en Ruby 2.7.0 incluyen coincidencia de patrones (experimental), mejoras en REPL, un GC de compactación y separación de argumentos posicionales y de palabras clave.

Rubí 3

Ruby 3.0.0 se lanzó el día de Navidad de 2020. Se conoce como Ruby 3x3, lo que significa que los programas se ejecutarían tres veces más rápido en Ruby 3.0 en comparación con Ruby 2.0. y algunos ya habían implementado en versiones intermedias en el camino de 2 a 3. Para lograr 3x3, Ruby 3 viene con MJIT, y más tarde YJIT, Just-In-Time Compilers, para hacer los programas más rápidos, aunque se describen como experimentales y permanecen. deshabilitado por defecto (habilitado por banderas en tiempo de ejecución).

Otro objetivo de Ruby 3.0 es mejorar la concurrencia y dos utilidades más, Fiber Scheduler y Ractor experimental, facilitan el objetivo. Ractor es liviano y seguro para subprocesos, ya que se logra mediante el intercambio de mensajes en lugar de objetos compartidos.

Ruby 3.0 introduce el lenguaje RBS para describir los tipos de programas de Ruby para el análisis estático. Está separado de los programas generales de Ruby.

También hay algunas mejoras de sintaxis y cambios en la biblioteca en Ruby 3.0.

Ruby 3.1 se lanzó el día de Navidad de 2021. Incluye YJIT, un compilador Just-In-Time nuevo y experimental desarrollado por Shopify para mejorar el rendimiento de las aplicaciones comerciales del mundo real. También se incluye un nuevo depurador. Hay algunas mejoras de sintaxis y otras mejoras en esta versión. Las bibliotecas de red para FTP, SMTP, IMAP y POP se mueven de gemas predeterminadas a gemas agrupadas.

Ruby 3.2 se lanzó el día de Navidad de 2022. Ofrece compatibilidad para ejecutarse dentro de un entorno WebAssembly a través de una interfaz WASI. Las expresiones regulares también reciben algunas mejoras, incluido un algoritmo de coincidencia memorizado más rápido para proteger contra ciertos ataques ReDoS y tiempos de espera configurables para la coincidencia de expresiones regulares. En esta versión también se incluyen funciones adicionales de depuración y sintaxis, que incluyen sugerencias de sintaxis y resaltado de errores. El compilador MJIT se ha vuelto a implementar como un módulo de biblioteca estándar, mientras que YJIT, un compilador JIT basado en Rust, ahora admite más arquitecturas en Linux.

Tabla de versiones

Semántica y filosofía

Yukihiro Matsumoto, el creador de Ruby

Matsumoto ha dicho que Ruby está diseñado para la productividad y la diversión del programador, siguiendo los principios de un buen diseño de interfaz de usuario. En una charla técnica de Google en 2008, Matsumoto declaró además: "Espero ver que Ruby ayude a todos los programadores del mundo a ser productivos, a disfrutar de la programación y a ser felices". Ese es el propósito principal del lenguaje Ruby." Él enfatiza que el diseño de sistemas debe enfatizar las necesidades humanas, en lugar de las de las computadoras:

A menudo las personas, especialmente los ingenieros informáticos, se centran en las máquinas. Piensan, "Al hacer esto, la máquina correrá rápido. Al hacer esto, la máquina funcionará más eficazmente. Al hacer esto, la máquina hará algo". Se están centrando en las máquinas. Pero de hecho necesitamos centrarnos en los humanos, en cómo los humanos se preocupan por hacer programación o operar la aplicación de las máquinas. Somos los maestros. Son los esclavos.

Matsumoto ha dicho que su principal objetivo de diseño era crear un lenguaje que él mismo disfrutara usando, minimizando el trabajo del programador y la posible confusión. Ha dicho que no había aplicado el principio de menor asombro (POLA) al diseño de Ruby; en una discusión de mayo de 2005 en el grupo de noticias comp.lang.ruby, Matsumoto intentó distanciar a Ruby de POLA, explicando que debido a que cualquier elección de diseño sorprenderá a alguien, usa un estándar personal para evaluar la sorpresa. Si ese estándar personal se mantiene constante, habrá pocas sorpresas para quienes estén familiarizados con el estándar.

Matsumoto lo definió así en una entrevista:

Todo el mundo tiene un fondo individual. Alguien puede venir de Python, alguien más puede venir de Perl, y pueden estar sorprendidos por diferentes aspectos del lenguaje. Entonces se me acercan y dicen: "Me sorprendió esta característica del lenguaje, así que Ruby viola el principio de menos sorpresa". Espera. El principio de menos sorpresa no es sólo para ti. El principio de menos sorpresa significa principio de lo menos # sorpresa. Y significa el principio de menos sorpresa después de aprender Ruby muy bien. Por ejemplo, yo era un programador C++ antes de empezar a diseñar Ruby. Programaba en C++ exclusivamente durante dos o tres años. Y después de dos años de programación C++, todavía me sorprende.

Ruby está orientado a objetos: cada valor es un objeto, incluidas clases e instancias de tipos que muchos otros lenguajes designan como primitivos (como enteros, booleanos y "null"). Las variables siempre contienen referencias a objetos. Cada función es un método y los métodos siempre se llaman en un objeto. Los métodos definidos en el ámbito de nivel superior se convierten en métodos de la clase Object. Dado que esta clase es un ancestro de todas las demás clases, estos métodos se pueden llamar en cualquier objeto. También son visibles en todos los ámbitos, sirviendo efectivamente como "global" procedimientos. Ruby admite la herencia con envío dinámico, mixins y métodos singleton (que pertenecen y están definidos para una sola instancia en lugar de estar definidos en la clase). Aunque Ruby no admite herencia múltiple, las clases pueden importar módulos como mixins.

Ruby se ha descrito como un lenguaje de programación multiparadigma: permite la programación procedimental (definir funciones/variables fuera de las clases las convierte en parte de la raíz, el Objeto 'yo'), con orientación a objetos (todo es un objeto) o programación funcional (tiene funciones anónimas, cierres y continuaciones; todas las declaraciones tienen valores y las funciones devuelven la última evaluación). Tiene soporte para introspección, reflexión y metaprogramación, así como soporte para subprocesos basados en intérpretes. Ruby presenta escritura dinámica y admite polimorfismo paramétrico.

Según las preguntas frecuentes de Ruby, la sintaxis es similar a la de Perl y la semántica es similar a la de Smalltalk, pero la filosofía de diseño difiere mucho de la de Python.

Características

• Totalmente orientada al objeto con herencia, mezclas y metaclases
• Teclado dinámico y pato
• Todo es una expresión (incluso declaraciones) y todo se ejecuta imperativamente (incluso declaraciones)
• Sintaxis sucinta y flexible que minimiza el ruido sintáctico y sirve de base para lenguajes específicos de dominio
• Reflexión dinámica y alteración de objetos para facilitar la metaprogramación
• Cierres léxicos, iteradores y generadores, con una sintaxis de bloques
• Notación literaria para arrays, hashes, expresiones regulares y símbolos
• Código de inserción en cadenas (interpolación)
• Default arguments
• Cuatro niveles de alcance variable (global, clase, instancia y local) denotados por sigiles o la falta de ellos
• Colección de basura
• Continuaciones de primera clase
• Reglas estrictas de coacción booleana (todo es verdadero excepto false y nil)
• Manejo de excepciones
• Operador sobrecarga
• Apoyo integrado para números racionales, números complejos y aritmética de precisión arbitraria
• Comportamiento de despacho personalizado (mediante method_missing y const_missing)
• Hilos nativos y fibras cooperativas (los fibras son una característica 1.9/YARV)
• Soporte para codificación Unicode y múltiples caracteres.
• API de plug-in nativo en C
• Interactive Ruby Shell, un intérprete interactivo de línea de comandos que se puede utilizar para probar el código rápidamente (REPL)
• Gestión centralizada de paquetes a través de RubyGems
• Aplicadas en todas las plataformas principales
• Gran biblioteca estándar, incluyendo módulos para YAML, JSON, XML, CGI, OpenSSL, HTTP, FTP, RSS, maldiciones, zlib y Tk
• Recopilación a tiempo

Sintaxis

La sintaxis de Ruby es muy similar a la de Perl y Python. Utiliza sangría y legible. Las definiciones de clase y método se señalan mediante palabras clave, mientras que los bloques de código se pueden definir mediante palabras clave o llaves. A diferencia de Perl, las variables no tienen un prefijo obligatorio con un sigilo. Cuando se usa, el sigilo cambia la semántica del alcance de la variable. A efectos prácticos no existe distinción entre expresiones y enunciados. Los saltos de línea son significativos y se toman como el final de una declaración; un punto y coma se puede utilizar de manera equivalente. A diferencia de Python, la sangría no es significativa.

Una de las diferencias con Python y Perl es que Ruby mantiene todas sus variables de instancia completamente privadas para la clase y solo las expone a través de métodos de acceso (attr_writer, attr_reader, etc.). A diferencia del "getter" y "colocador" métodos de otros lenguajes como C ++ o Java, los métodos de acceso en Ruby se pueden crear con una sola línea de código a través de la metaprogramación; sin embargo, los métodos de acceso también se pueden crear de la manera tradicional de C++ y Java. Como la invocación de estos métodos no requiere el uso de paréntesis, es trivial cambiar una variable de instancia en una función completa, sin modificar una sola línea de código de llamada o tener que hacer ninguna refactorización para lograr una funcionalidad similar a la propiedad de C# y VB.NET. miembros

Los descriptores de propiedades de Python son similares, pero vienen con una compensación en el proceso de desarrollo. Si uno comienza en Python usando una variable de instancia expuesta públicamente y luego cambia la implementación para usar una variable de instancia privada expuesta a través de un descriptor de propiedad, es posible que sea necesario ajustar el código interno de la clase para usar la variable privada en lugar de la propiedad pública.. El diseño de Ruby obliga a que todas las variables de instancia sean privadas, pero también proporciona una forma sencilla de declarar los métodos set y get. Esto está de acuerdo con la idea de que en Ruby, uno nunca accede directamente a los miembros internos de una clase desde fuera de la clase; más bien, uno pasa un mensaje a la clase y recibe una respuesta.

Implementaciones

Intérprete Ruby de Matz

El intérprete de Ruby original a menudo se conoce como el intérprete de Ruby de Matz o MRI. Esta implementación está escrita en C y utiliza su propia máquina virtual específica de Ruby.

La implementación Ruby 1.8 estandarizada y retirada se escribió en C, como un lenguaje interpretado de un solo paso.

A partir de Ruby 1.9 y continuando con Ruby 2.x y posteriores, el intérprete oficial de Ruby ha sido YARV ("Yet Another Ruby VM"), y esta implementación ha reemplazado a la máquina virtual más lenta que se usaba en versiones anteriores de MRI.

Implementaciones alternativas

A partir de 2018, existen varias implementaciones alternativas de Ruby, incluidas JRuby, Rubinius y mruby. Cada uno adopta un enfoque diferente, con JRuby y Rubinius brindando compilación justo a tiempo y mruby también brinda compilación anticipada.

Ruby tiene tres implementaciones alternativas principales:

• JRuby, una implementación mixta Java y Ruby que funciona en la máquina virtual Java. JRuby se dirige actualmente a Ruby 3.1.x.
• TruffleRuby, una implementación de Java usando el marco de implementación del idioma Truffle con GraalVM
• Rubinius, una máquina virtual C++ bytecode que utiliza LLVM para compilar al código de máquina en tiempo de ejecución. El compilador de bytecode y la mayoría de las clases principales están escritas en Ruby puro. Rubinius actualmente apunta a Ruby 2.3.1.

Otras implementaciones de Ruby incluyen:

• MagLev, una implementación de Smalltalk que funciona en GemTalk Systems' GemStone/S VM
• mruby, una implementación diseñada para ser incrustada en código C, en una vena similar a Lua. Actualmente está siendo desarrollado por Yukihiro Matsumoto y otros
• RGSS, o Ruby Game Scripting System, una aplicación patentada que es utilizada por la serie RPG Maker de software para el diseño y modificación del motor RPG Maker
• julializador, un transpilador (partial) de Ruby a Julia. Se puede utilizar para una gran velocidad por ejemplo. Implementaciones Ruby o JRuby (puede ser solamente útil para código numérico).
• Topaz, una implementación de Ruby escrita en Python
• Opal, un intérprete web que compila Ruby a JavaScript

Otras implementaciones de Ruby ahora desaparecidas fueron:

• MacRuby, una aplicación Mac OS X en el tiempo de ejecución Objetivo-C. Su contraparte iOS se llama RubyMotion
• IronRuby una implementación en el. Marco NET
• Cardenal, una implementación para la máquina virtual Parrot
• Ruby Enterprise Edition, a menudo acortada ree, una implementación optimizada para manejar proyectos de Ruby a gran escala en Rails
• HotRuby, una aplicación JavaScript y ActionScript del lenguaje de programación Ruby

La madurez de las implementaciones de Ruby tiende a medirse por su capacidad para ejecutar el marco Ruby on Rails (Rails), porque es complejo de implementar y utiliza muchas características específicas de Ruby. El punto en el que una implementación en particular logra este objetivo se denomina "la singularidad de Rails". La implementación de referencia, JRuby y Rubinius pueden ejecutar Rails sin modificaciones en un entorno de producción.

Soporte de plataforma

Matsumoto originalmente desarrolló Ruby en Sony NEWS-OS 3.x basado en 4.3BSD, pero luego migró su trabajo a SunOS 4.xy finalmente a Linux. En 1999, se sabía que Ruby funcionaba en muchos sistemas operativos diferentes. Las versiones e implementaciones modernas de Ruby están disponibles en todos los principales sistemas operativos de escritorio, móviles y basados en servidor. Ruby también es compatible con varias plataformas de alojamiento en la nube como Jelastic, Heroku, Google Cloud Platform y otras.

Herramientas como RVM y RBEnv facilitan la instalación y el particionamiento de múltiples versiones de Ruby y múltiples 'gemsets' en una máquina.

Repositorios y bibliotecas

RubyGems es el administrador de paquetes de Ruby. Un paquete de Ruby se denomina "gema" y se puede instalar a través de la línea de comandos. La mayoría de las gemas son bibliotecas, aunque existen algunas que son aplicaciones, como IDE. Hay más de 100 000 gemas Ruby alojadas en RubyGems.org.

Muchas bibliotecas de Ruby nuevas y existentes están alojadas en GitHub, un servicio que ofrece alojamiento de repositorio de control de versiones para Git.

El archivo de aplicaciones de Ruby, que albergaba aplicaciones, documentación y bibliotecas para la programación de Ruby, se mantuvo hasta 2013, cuando su función se transfirió a RubyGems.