Alles ist ein Objekt

Ruby ist eine Programmiersprache, die, obwohl sie auch viele andere Programmierparadigmen unterstützt, von Grund auf objektorientiert ist. Das bedeutet konkret, dass in Ruby ausnahmslos jeder Wert ein Objekt und jede Funktion eine Methode ist (d. h. einer Klasse zugeordnet ist). Ausnahmen für primitive Datentypen wie in vielen anderen objektorientierten Programmiersprachen gibt es nicht. Auch Klassen sind Objekte. Objekte speichern Instanzvariablen und haben eine Klasse. Klassen sind Objekte, die Methoden speichern und eine Vererbungshierarchie besitzen. Auf Instanzvariablen kann ausschließlich über Methoden zugegriffen werden.

class TestKlasse
end
test_objekt = TestKlasse.new

puts 1.class            # => Integer
puts "text".class       # => String
puts test_objekt.class  # => TestKlasse
puts TestKlasse.class   # => Class
puts Class.class        # => Class

Werden in Ruby „Funktionen“ definiert, so sind das in Wirklichkeit Methoden, die dem Objekt Object hinzugefügt werden. In Ruby erben alle Objekte implizit von Object, weswegen so definierte „Funktionen“ in jedem Objekt und damit allgegenwärtig verfügbar sind. Allerdings werden diese Funktionen als private markiert, das heißt, sie können nicht von außen auf einem Objekt aufgerufen werden.

# Definiere „Funktion“
def meine_funktion
  puts "Hier bin ich"
end

# Kann in andern Objekten wie eine Funktion benutzt werden
class ABC
  def gib_meine_funktion_aus
    meine_funktion
  end
end
mein_abc = ABC.new
mein_abc.gib_meine_funktion_aus # => Hier bin ich
mein_abc.meine_funktion # => Fehlermeldung, private method `meine_funktion' called

Da in Ruby Objekte dynamisch sind, kann man mit Ruby auch prototypbasiert programmieren. Das bedeutet grob, dass Objekte eigene Methoden haben können (außerhalb der von der Klasse vorgegebenen) und kopiert und verändert werden können (da nur Klassen Methoden beinhalten können, wird im Hintergrund eine versteckte neue Klasse nur für das eine Objekt angelegt).

auto1 = Object.new
def auto1.beschleunigen
  puts "brumm brumm brumm"
end

auto1.beschleunigen # => "brumm brumm brumm"

auto2 = auto1.clone
def auto2.bremsen
  puts "quietsch"
end

auto2.beschleunigen # => "brumm brumm brumm"
auto2.bremsen       # => "quietsch"

Blöcke

In den meisten höheren Programmiersprachen ist es möglich, Funktionen in irgendeiner Form zusätzlich als Parameter Logik zu übergeben, sei es durch First-Class-Funktionen oder First-Class-Objekte (deren Methoden dann die Logik bereitstellen). Das ist in Ruby nicht anders, allerdings hat Ruby den Spezialfall, dass genau eine Funktion übergeben wird, syntaktisch (und auch von der Rechenleistung) stark optimiert. Dieser Spezialfall wird Block genannt, gemeint als ein Block Programmierlogik, den die Funktion zu benutzen hat.

Blöcke werden Funktionen als separate Parameter übergeben und folgen als letztes Argument, eingegrenzt durch geschwungene Klammern oder die Schlüsselworte do und end. Im Folgenden wird die Methode times des Objekts 10 aufgerufen und ein Block übergeben. Beide Aufrufe sind identisch.

10.times {
  puts "Hallo Welt!"
}
10.times do
  puts "Hallo Welt!"
end

Zusätzlich können Blöcken Parameter übergeben werden und sie haben auch einen Rückgabewert. Zum Aufrufen des übergebenen Blocks wird innerhalb der aufgerufenen Methode das Schlüsselwort yield verwendet. Werden yield Parameter angegeben, so werden diese dem Block übergeben, der sie zu Beginn als lokale Variablen deklarieren oder ignorieren kann. Blöcke (ebenso wie Methoden) geben automatisch den letzten Ausdruck des Blockes als Rückgabewert zurück (mittels break und next kann aber auch an anderen Stellen zurückgesprungen werden).

def methode_die_block_aufruft(übergebener_parameter)
  eigene_variable = "Hallo"
  rückgabe = yield eigene_variable, übergebener_parameter
  if rückgabe == "ok"
    puts "☺"
  end
end

# Aufruf
methode_die_block_aufruft("aus Ruby") do |p1,p2| # die Blockargumente werden innerhalb || in Block-lokale Variablen umgewandelt
  puts p1 + " " + p2 + "!"
  "ok"
end
# Zuerst wird im Block „Hallo aus Ruby!“ ausgegeben,
# dann in der Methode ☺, da der Rückgabewert „ok“ war

Blöcke können auch in Funktionsobjekte umgewandelt werden. Wird innerhalb der Parameterliste einer Methode vor den letzten Parameter ein & geschrieben, wandelt Ruby den übergebenen Block in ein Proc (ein Funktions-Objekt) um. Alternativ können Procs auch manuell durch die Schlüsselworte proc, lambda und -> angelegt werden. Aufgerufen werde diese Objekte durch die Methoden call, [] oder .(). Da Ruby runde Klammern lediglich zum Gruppieren nutzt, können Procs nicht (wie in anderen Programmiersprachen üblich) mit proc_name() aufgerufen werden.

def mache_block_zu_proc &block
  block # ist der Rückgabewert, da letzter Ausdruck
end
a = mache_block_zu_proc{|a,b| a + b}
b = proc {|a,b| a - b} # ein return innerhalb des Blocks verlässt die beinhaltende Methode, break nur den Block
c = lambda {|a,b| a * b} # wie proc, aber return innerhalb des lambdas verlässt nur diesen Block
d = -> (a,b) {a / b} # neue Schreibweise für lambda, runde Klammern sind optional
a.call(1,2) # => 3
b[1,2]      # => -1
c.(1,2)     # => 2

# Beispiel für funktionale Programmierung
e = d.curry.(8) # neues Proc das den (oder die) ersten Parameter (den Dividenden hier) als 8 setzt
e.(2)       # => 4
# mit & können Proc-Objekte (eigentlich jede Klasse die eine call Methode hat) wieder in Blöcke umgewandelt werden
[8,4,2,1].map(&e) # => [1, 2, 4, 8]

Alle Blöcke sind Closures, sie speichern also z. B. den Zustand lokaler Variablen, wenn sie innerhalb des Blocks dauerhaft benötigt werden.

Mixins

Ruby beherrscht bewusst keine Mehrfachvererbung, bietet stattdessen aber ein Konzept namens Mixin (deutsch: Beimischung). Mixins sind Sammlungen von Methoden, die beliebigen Klassen beigemischt werden können. Eine Klasse kann beliebig viele Mixins beinhalten. Mixins werden in der Vererbungshierarchie zwischen Klasse und Superklasse in der Reihenfolge eingehängt, in der sie geschrieben wurden. Alternativ ist es auch möglich, Mixins vor die eigentliche Klasse zu hängen (u. a. hilfreich für Aspektorientierte Programmierung). Um Mixins zu definieren, werden in Ruby Module benutzt, das sind quasi Klassen (d. h. Sammlungen von Methoden) die nicht instanziiert werden können und Namensräume in einem.

class Tier
  def sagt
    puts "#{self.class} sagt nichts" # "text#{logik}text" ist Rubys Textinterpolation
  end
end

module KannSchwimmen # Module, d. h. KannSchwimmen.new geht nicht
  def schwimmt
    puts "#{self.class} schwimmt" # self gibt die Instanz zurück,
  end                             #  jedes Objekt hat eine Methode .class die das Klassenobjekt zurück gibt
end

module KannNichtSchwimmen
  def schwimmt
    puts "#{self.class} geht unter"
  end
end

class Fisch < Tier # Vererbung wird durch den Kleiner-Als-Operator gekennzeichnet
  include KannSchwimmen # füge KannSchwimmen zwischen Fisch und Tier ein
end

class Vogel < Tier
  include KannNichtSchwimmen
  def sagt # übliches Vererben, überdecke sagt-Methode von Tier
    puts "#{self.class}: Piep"
  end
end

class Mensch < Tier
  include KannSchwimmen
  def sagt
    puts "#{self.class}: Ich kann mich besser ausdrücken"
  end
end

class NichtSchwimmer < Mensch
  prepend KannNichtSchwimmen # hänge KannNichtSchwimmen vor NichtSchwimmer ein,
end                          # dh, überdecke die schwimmt-Methode

fisch = Fisch.new
mensch = Mensch.new
vogel = Vogel.new
nicht_schwimmer = NichtSchwimmer.new

fisch.sagt                # => Fisch sagt nichts
vogel.sagt                # => Vogel: Piep
mensch.sagt               # => Mensch: Ich kann mich besser ausdrücken
nicht_schwimmer.sagt      # => NichtSchwimmer: Ich kann mich besser ausdrücken
puts
fisch.schwimmt            # => Fisch schwimmt
vogel.schwimmt            # => Vogel geht unter
mensch.schwimmt           # => Mensch schwimmt
nicht_schwimmer.schwimmt  # => NichtSchwimmer geht unter

class Numeric # ruby-interne Klasse
  def inverse # neue Methode, berechne den Kehrwert
    1.0 / self
  end
end

5.inverse # => 0.2

Domänenspezifische Sprache

Ruby wird gerne benutzt zum Erzeugen von domänenspezifischen Sprachen. Das sind Textbausteine, die weniger wie Programmcode aussehen, sondern mehr wie eine Auszeichnungssprache, in Wirklichkeit aber normaler Ruby-Code sind. Möglich macht das zum einen die flexible Schreibweise von Ruby, bspw. sind Klammern hinter Methodenaufrufen oder Semikola am Ende der Zeile optional. Zum anderen bietet Ruby viele Möglichkeiten zur Metaprogrammierung, die es möglich machen, redundante Ausdrücke verschwinden zu lassen und hinter den Kulissen das Programm zu verändern. Hier als Beispiel die Konfiguration einer Testfabrik für FactoryBot:

FactoryBot.define do
  factory :user do
    first_name "Max"
    last_name  "Mustermann"
    admin false
  end
  factory :admin, class: User do
    first_name "Admin"
    last_name  "Root"
    admin true
  end
end

Mächtige Standardbibliothek

Die Kern-Klassen (String, Integer, Float, Array, Hash, Range, Regexp) bringen eine Fülle an Methoden mit, die in jedem Rubyprogramm sofort verwendet werden können. Insbesondere durch die häufige Nutzung von Blöcken können mit diesen Methoden lange Programme auf wenige Zeilen reduziert werden, weshalb sich Ruby gut zum Zeigen von Proof of Concepts eignet. Besonders hervor hebt sich das Modul Enumerable, welches viele Konzepte der funktionalen Programmierung direkt in den Ruby-Kern bringt. Enumerable kann in jedes Objekt eingebunden werden, welches einen iterierbaren Container darstellt und die Methode each implementiert, bspw. die Klassen Array, Hash und Range. For-Schleifen sind in Ruby deshalb meist unnötig. Die im Folgenden gezeigten Methoden reduce, count, sort_by, each_slice und map sind alles Methoden aus Enumerable und können somit selbst erstellten Klassen leicht hinzugefügt werden.

# summiere die zahlen 1 bis 100 (ohne Summenformel), reduce entspricht fold aus der funktionalen Programmierung
(1..100).reduce{|counter,number| counter + number} # (1..100).sum geht auch
# Array aus den Zahlen von 0 bis 30 in 5er Schritten
(0..30).step(5).to_a
# Anzahl der Zeilen einer Datei die leer sind (ohne die Datei komplett in den Arbeitsspeicher zu laden)
IO.foreach("Dateiname").count{|line| line =~ /^\s*$/}
# Sortiere Array nach Länge der Nachnamen
["Max Mustermann", "John Doe", "Tarou Yamada"].sort_by{|name| name.split.last.length}
# Schreibe jedes dritte Wort im Satz in Großbuchstaben
"Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.".split.each_slice(3).map{|drei_wörter| drei_wörter.last.upcase!; drei_wörter}.flatten.join(" ")

Zusätzlich zu den integrierten Modulen wird Ruby standardmäßig mit vielen Modulen ausgeliefert. Bspw. sind Unterstützung für JSON, YAML, HTTP, Benchmarks, Primzahlen, sichere Zufallszahlen, OpenSSL und Logging sofort vorhanden.

Metaprogrammierung

Ruby bietet weitreichende Möglichkeiten zu Metaprogrammierung an. Damit ist es z. B. möglich, Methoden zu generieren, Instanzvariablen auszutauschen, die Vererbungshierachie zu verändern oder Konstanten zu bearbeiten. Die Syntax zu verändern oder weitere Operatoren hinzuzufügen geht allerdings nicht. Hier sei als Beispiel eine Methode aufgeführt, Setter und Getter automatisch zu erzeugen (unter den Namen attr_reader, attr_writer, attr_accessor bereits im Standard enthalten).

class Object # Monkey-Patching aller Klassen
  def self.getter *args # self ist hier Object, es wird eine Klassenmethode erzeugt
    args.each do |arg| # es wird durch alle Parameter iteriert
      define_method arg do # define_method(arg){block} erzeugt eine neue Methode des Namens arg mit dem Inhalt block
        instance_variable_get("@#{arg}".to_sym) # instance_variable get gibt den Wert der Instanzvariablen des übergeben Namens zurück
      end                                       # \- "@#{arg}" hängt ein @ vor den Inhalt von arg, to_sym wandelt den String um in ein Symbol
    end
  end
  def self.setter *args # *args packt alle Parameter in ein Array namens args
    args.each do |arg|
      define_method :"#{arg}=" do |new_value|              # define_method übergibt dem Block die übergeben Parameter
        instance_variable_set("@#{arg}".to_sym, new_value) # \- setter-methoden enden mit einem =
      end
    end
  end
end

class PaarMit2
  def initialize links # Konstruktor
    @links = links # Instanzvariblen werden bei Erwähnung in einer beliebigen Methode automatisch erzeugt
    @rechts = 2
  end
  getter :links, :rechts
  setter :links
end

paar = PaarMit2.new(4) # new ruft immer den Konstruktor auf
paar.links       # => 4
paar.rechts      # => 2
paar.links = 9   # => 9
paar.links       # => 9
paar.rechts = 8  # => Fehler: NoMethodError (undefined method `rechts=')

Diese Techniken eignen sich auch gut zum Debuggen von Anwendungen oder zum Analysieren schlecht dokumentierter Anwendungen oder Bibliotheken. Bspw. antwortet jedes Objekt beim Aufruf der Methode methods mit einer Liste aller seiner Methoden, instance_variables gibt eine Liste aller Instanzvariablen zurück.

Integration in Unix

Ruby bietet sich, ähnlich wie Perl, an, direkt in die Pipeline der Unix-Shell integriert zu werden. Möglich machen das Kommandozeilenparameter des Rubyinterpreters, die ermöglichen Programmlogik und übliches Programmverhalten zu definieren (üblicherweise die gleiche Operation auf jeder Zeile auszuführen). Ruby erweitert die Standard-Unixwerkzeuge mit fortgeschrittenen Methoden zur Textanalyse und Textverarbeitung.

Weiterhin bietet Ruby auch die Möglichkeit, innerhalb eines Programms bequem Prozesse zu starten, deren Eingabe zu steuern und Ausgabe und Rückgabewerte auszulesen. Code innerhalb `` wird direkt an die Unix-Shell übergeben. Bspw. speichert der Befehl os_string = `uname -a` den Betriebssystemnamen direkt in eine Rubyvariablen. Der Rückgabewert des letzten Programmaufrufs wird analog zur Shell automatisch in der globalen Variablen $? gespeichert. Auch Signalbehandlung, Sockets und Threads werden ohne zusätzliche Bibliotheken direkt vom Sprachkern unterstützt. Zum Beschleunigen der Verarbeitung gibt es in Ruby ein Modul namens FileUtils, das viel der Funktionalität vieler Unix-Dateiverwaltungsprogramme (rm, cp, chmod) direkt in Ruby abbildet.

Syntax und Grundlagen

a = "ABC"
b = a.downcase
puts a, b # => ABC abc
a.downcase!
puts a, b # => abc abc

def gib_summe_aus arg1, arg2
  # Methodenlogik
  unless arg1.is_a?(Numeric) && arg2.is_a?(Numeric)
    raise ArgumentError.new("Bitte nur Zahlen eingeben") # raise wirft Fehler
  end
  puts arg1 + arg2
rescue ArgumentError => e # Fange ArgumentError ab
  puts "Es ist ein Fehler bei der Parameterübergabe aufgetreten"
rescue => e # Fange alle weiteren Fehler ab
  puts e.message
ensure # wird auf jeden Fall ausgeführt
  puts 'Methodenende'
end

a = 5
if a < 10;  puts a; end
puts a if a < 10 # Suffixform
unless a >= 10; puts a; end # Invers
puts a unless a >= 10 # Invers + Suffixform

while a < 10;  puts a;  a += 1; end
(puts a; a+=1) while a < 20 # Suffixform
until a >= 30;  puts a;  a += 1; end # Invers
(puts a; a +=1) until a >= 40 # Invers + Suffixform

Interaktive Ruby-Shell

Interactive Ruby (irb) ist eine Read-Eval-Print Loop (REPL), mit welcher der Anwender interaktiv Ruby programmieren kann. Irb wird mit dem Ruby-Interpreter ausgeliefert und kann zum Analysieren und Testen eingesetzt werden:

irb(main):001:0> (5 + 7) * 2
=> 24
irb(main):002:0> ((5 + 7) * 2).to_s.reverse
=> "42"
irb(main):003:0> "Ein Beispielstring".size
=> 18

Als Alternative zu Irb gibt es Pry, eine REPL, welche weitaus tiefgreifendere Möglichkeiten zur Introspektion und zum Debuggen mitbringt.

RDoc und ri

RDoc ist ein Software-Dokumentationswerkzeug, welches aus Ruby- und C-Quelltexten automatisch HTML-Dokumentationsdateien erstellt. Weiterhin wird eine Datenbank aufgebaut, die mit dem Tool ri durchsucht werden kann. RDoc und ri sind Bestandteil der Standarddistribution und werden zusammen mit dem Interpreter ausgeliefert.

Rake

Rake steht für Ruby-Make und ist eine Alternative zu Make aus C. Da es in Ruby keine Kompilationsphase gibt, dienen Rakefiles zum Automatisieren repetitiver Aufgaben, bspw. dem Generieren von Dokumentation, dem Upload von Dateien oder dem Packen von Projekten. Rake kann wie Make Abhängigkeiten auflösen, wenn für Aufgabe B erst Aufgabe A erfüllt sein muss, so führt Rake automatisch Aufgabe A aus. Rake ist eine domänenspezifische Sprache, d. h., es lässt sich bequem wie eine Auszeichnungssprache lesen, bietet aber die vollen Möglichkeiten die Ruby bietet.

Paketverwaltung

Ruby-Bibliotheken werden üblicherweise als Gems (RubyGems) gepackt und auf rubygems.org, dem zentralen Gem-Register, veröffentlicht. RubyGems löst bei der Installation oder bei Updates die im Paket angegebenen Abhängigkeiten eigenständig rekursiv auf und bietet dabei sogar die Möglichkeit Pakete gleichzeitig in unterschiedlichen Versionen bereitzustellen. Seit Ruby 1.9 ist Rubygems Bestandteil der Standardbibliothek von Ruby. Heute wird es meist zusammen mit Bundler benutzt (ebenfalls Teil der Standardbibliothek, seit Ruby 2.6), einem Programm welches Schnappschüsse aus einer Kollektion von Gems erstellt und diese Anordnung auf anderen Maschinen (oder andern Projektordnern) wiederherstellen kann.

Referenzimplementierung

Die Referenzimplementierung von Ruby wurde von Yukihiro „Matz“ Matsumoto als Interpreter in C entworfen. Dieser wird meist als MRI (Matz’s Ruby Interpreter) oder auch als CRuby bezeichnet und ist derzeit am weitesten verbreitet. Den Kern bildet YARV (Yet Another Ruby VM), eine virtuelle Maschine. Statt ein Rubyprogramm direkt auszuführen, wird es zunächst in Bytecode übersetzt und dann von YARV interpretiert, wodurch sich ein Geschwindigkeitsvorteil ergibt. Weiterhin enthält diese Version eine leistungsstarke Regexp-Maschine namens Oniguruma und unterstützt Multibyte-Zeichensätze wie UTF-8.

Der offizielle Interpreter läuft auf den folgenden Betriebssystemen:

• POSIX-kompatible Systeme (u. a. Linux, BSD und macOS)
• Windows (aktuelle Versionen benötigen MSYS2 und laufen demnach ab Vista)

Alternative Implementierungen

Es gibt zahlreiche alternative Ruby-Implementierungen mit unterschiedlichem Umfang und Zielen:

• JRuby ist eine Implementierung des Ruby-Interpreters in Java mit dem Ziel, Ruby nahtlos in die Java-Plattform zu integrieren. JRuby ist fast vollständig kompatibel zu Ruby 3.1. JRuby ist zudem kompatibel zu einigen Ruby-Erweiterungen von Rubinius (Foreign Function Interface, Multi-VM-API), allerdings nicht mit C-Erweiterungen von CRuby.
• Mruby ist eine weitere Ruby-Implementierung erschaffen vom Ruby-Schöpfer Yukihiro Matsumoto. Mruby ist eine auf eingebettete Systeme zugeschnittene Version von Ruby, welche sich durch geringen Speicherbedarf und hohe Modularisierung auszeichnet. Mruby stellt nicht die vollständige Funktionalität von CRuby bereit. Mruby kann den Quellcode in Bytecode übersetzen, welcher dann ohne Kompilationsschritt interpretiert oder in C-Programme eingebettet werden kann.
• Opal ist ein Compiler von Ruby nach JavaScript. Es handelt sich um eine Implementierung der Ruby-Corelib und Stdlib sowie den zugehörige Gems. Mit Opal lassen sich clientseitige Webanwendungen in Ruby realisieren. Es gibt einige Einschränkungen, die der Umsetzung nach JavaScript geschuldet sind.
• TruffleRuby ist eine Ruby-Implementierung die auf der GraalVM läuft. Ziel der Implementierung ist es die Vorteile der GraalVM mittels Ruby nutzbar zu machen. Diese sind Geschwindigkeit (Start- und Laufzeit), Parallelisierung und das kontrollierte Ausführen von C-Erweiterungen. TruffleRuby ist open-source und wird maßgeblich von Oracle entwickelt.
• Fullstaqruby ist keine eigene Implementierung, sondern eine spezielle Distribution von MRI, die für den Einsatz auf Webservern optimiert wurde. Im Vergleich zur Referenzimplementierung verspricht Fullstaqruby eine bessere Performance bei geringerem Speicherverbrauch.

Historische Ruby-Implementierungen:

• Rubinius ist eine von Smalltalk-80 inspirierte Implementierung. Abgesehen von der virtuellen Maschine ist Rubinius vollständig in Ruby geschrieben. Rubinius ist nahezu vollständig kompatibel zu Ruby 2.3. Rubinius nutzt die Low Level Virtual Machine (LLVM) und ist kompatibel mit C-Erweiterungen der Referenzimplementierung. Seit 2020 gibt es keine Bewegung mehr im Projekt und die Projektwebseite ist mittlerweile leer.
• IronRuby ist eine Implementierung, die Ruby ins .NET Framework integriert und in C# implementiert ist.
  Das Projekt ist seit 13. März 2011 inaktiv und wird nicht mehr weiterentwickelt.
• Cardinal, ein Interpreter für die virtuelle Maschine Parrot. Das Projekt ist seit Juni 2013 inaktiv.
• MagLev ist eine Implementierung des Unternehmens Gemstone für deren proprietäre Smalltalk VM. Das Projekt ist seit 2015 inaktiv.
• MacRuby ist eine Implementierung in Objective-C von Apple, die bis Version 0.4, wie Ruby 1.9, YARV nutzt, ab Version 0.5 allerdings, wie Rubinius, auf die LLVM setzt. Die Weiterentwicklung wurde mit dem 5. Januar 2015 eingestellt.
• Ruby Enterprise Edition ist eine modifizierte Version der Referenzimplementierung, bei der im Wesentlichen der Garbage Collector neu implementiert wurde. REE ist lediglich mit Ruby 1.8 kompatibel, die aktuellste Version stammt aus dem Jahr 2012.

Die Kompatibilität zur Referenzimplementierung wird durch das RubySpec-Projekt überprüft. Es stellt dabei sowohl eine Testsuite als auch eine Spezifikation für Ruby dar. RubySpec war ursprünglich ein Teil von Rubinius, wurde aber ausgelagert und danach auch von einer Vielzahl anderer Entwickler vorangetrieben. Es wird in vielen Ruby-Implementierungen verwendet.

Mit Hilfe eines Versionsmanagers, wie beispielsweise RVM (Ruby Version Manager) oder Rbenv, besteht die Möglichkeit, mehrere Ruby-Versionen parallel zu betreiben.

Ein wichtiges Merkmal der Implementierungen ist, ob sie in der Lage sind, Ruby on Rails auszuführen. Derzeit können dies neben der Referenzimplementierung nur JRuby, Rubinius und TruffleRuby.

Nutzungsbedingungen

Ruby ist eine freie Software. Deshalb ist es kostenlos nutzbar und im Quelltext verfügbar. Dadurch ergibt sich die Möglichkeit, die Sprache an seine eigenen Bedürfnisse anzupassen oder sie in eigene Programme einzubinden.

Der Interpreter und die Standardbibliothek von Ruby sind grundsätzlich unter den Bedingungen der 2-clause BSD-Lizenz nutzbar. Des Weiteren besteht die Möglichkeit, Ruby unter einer eigenen freien Lizenz zu verwenden. Die Ruby-Lizenz ist GPL-kompatibel und wird von der Free Software Foundation als „frei“ akzeptiert.

Ältere Versionen von Ruby (1.9.2 und früher) verwendeten anstatt der BSD-Lizenz die GPL V2. Als Begründung für den Wechsel wurden Inkompatibilitäten der alten Lizenzierung mit der GPL V3 angeführt.

RubyForge

RubyForge war ein kollaborativer Filehosting-Dienst für in Ruby geschriebene Softwareprojekte. Er wurde im Jahr 2003 von Ruby Central gestartet, um der Ruby-Community eine Heimat für ihre Open-Source-Projekte zur Verfügung zu stellen.

Am 29. November 2009 wurden dort über 9.300 Projekte und mehr als 94.683 Benutzer geführt, am 15. Mai 2014 wurde der Dienst schließlich eingestellt.