Warum das Ganze? Klassische Ansätze wie Single Table Inheritance (STI) oder „nackte“ polymorphe Assoziationen stoßen schnell an Grenzen: STI bläht Tabellen auf, polymorphes CRUD bleibt oft mühsam zu paginieren. Das Recordable Pattern nutzt Rails’ Delegated Types, um eine dünne, performante „Superklasse“-Tabelle (Recording) mit schlanken „Subklasse“-Tabellen (Recordables wie Message, Document, Comment) zu kombinieren.

Das Grundprinzip

• Eine zentrale Tabelle „recordings“ hält alle gemeinsamen Metadaten (z. B. Bucket, Creator, Timestamps) und verweist polymorph auf den „konkreten Inhalt“ (recordable).
• Jede konkrete Recordable (Message, Document, Comment) hat eine eigene Tabelle mit genau ihren Feldern.
• Abfragen, Pagination und gemeinsame Logik passieren über Recording; konkretes Verhalten (z. B. export_html) lebt bei den Recordables.

So bleibst du:

• flexibel (neue Typen ohne Recording-Migration),
• performant (einheitliche Timeline auf der dünnen Recording-Tabelle),
• sauber getrennt (Metadaten vs. Inhalte).

Minimales Datenmodell

Migration (gekürzt auf das Wesentliche):

create_table :recordings do |t|
  t.references :bucket,  null: false, foreign_key: true
  t.references :creator, null: false, foreign_key: { to_table: :users }
  t.string  :recordable_type, null: false
  t.bigint  :recordable_id,   null: false
  t.index [:recordable_type, :recordable_id]
  t.bigint :parent_id # optional: Recording-Baum (Unterelemente)
  t.index :parent_id
  t.timestamps
end
add_foreign_key :recordings, :recordings, column: :parent_id

create_table :messages do |t|
  t.string :title,   null: false
  t.text   :content, null: false
  t.timestamps
end

create_table :documents do |t|
  t.string :title, null: false
  t.text   :body
  t.string :external_url
  t.timestamps
end

create_table :comments do |t|
  t.text :body, null: false
  t.timestamps
end

Models und Concerns

Recording: die „Superklasse“ mit Delegation

class Recording < ApplicationRecord
  belongs_to :bucket
  belongs_to :creator, class_name: "User"

  delegated_type :recordable, types: %w[Message Document Comment], dependent: :destroy

  # optional: Baumstruktur
  belongs_to :parent, class_name: "Recording", optional: true
  has_many   :children, class_name: "Recording", foreign_key: :parent_id, dependent: :nullify

  # Bequeme Filter-Scopes kommen mit delegated_type:
  # Recording.messages, Recording.documents, Recording.comments
end

Recordable-Concern: gemeinsame API für Inhalte

module Recordable
  extend ActiveSupport::Concern

  included do
    has_many :recordings, as: :recordable, inverse_of: :recordable
  end

  def display_title
    respond_to?(:title) ? title : self.class.name
  end

  def export_html
    "#{display_title}"
  end
end

Konkrete Typen:

class Message < ApplicationRecord
  include Recordable
  validates :title, :content, presence: true

  def export_html
    "#{title}#{content}"
  end
end

class Document < ApplicationRecord
  include Recordable
  validates :title, presence: true

  def export_html
    if external_url.present?
      "#{title}External: #{external_url}"
    else
      "#{title}#{body}"
    end
  end
end

class Comment < ApplicationRecord
  include Recordable
  validates :body, presence: true

  def display_title
    body.truncate(40)
  end

  def export_html
    "#{body}"
  end
end

Erstellen und Paginieren einer Timeline

Bucket kapselt die Aufnahme neuer Inhalte („record“) und die Timeline. Bucket ist hier eher abstrakt und könnte genausogut auch ein Projekt sein, oder ein Kunde:

class Bucket < ApplicationRecord
  has_many :recordings, dependent: :destroy

  def timeline(limit: 50)
    recordings.order(created_at: :desc).limit(limit).includes(:recordable)
  end

  def record(recordable, creator:, parent: nil, color: nil)
    recordings.create!(recordable: recordable, creator: creator, parent: parent, color: color)
  end
end

Typische Abfragen:

bucket = Bucket.find(1)

# Gesamte Timeline effizient paginieren
bucket.timeline(limit: 50).each do |rec|
  puts "[#{rec.recordable_type}] #{rec.recordable.display_title}"
end

# Nur bestimmte Typen (Scopes via delegated_type)
Recording.messages.where(bucket: bucket).limit(20)
Recording.documents.where(bucket: bucket).order(created_at: :desc)

Versionierung per Repointing (immutable Recordables)

Statt Inhalte zu „updaten“, erzeugst du neue Recordables und verweist die Recording-Zeile auf die neue Version. Das hält Historie sauber und macht Kopieren effizient.

class Recording < ApplicationRecord
  # ...

  def repoint_to!(new_recordable)
    update!(recordable: new_recordable)
  end
end

# Beispiel: Message ? neue Document-Version
msg_rec = bucket.record(Message.create!(title: "Kickoff", content: "Welcome!"), creator: user)
new_doc = Document.create!(title: "Specs v2", body: "Updated requirements")
msg_rec.repoint_to!(new_doc) # Recording zeigt nun auf Document

Wenn du eine echte Ereignis-Historie brauchst, ergänze ein Event-Model und schreibe beim record/repoint_to! Einträge (z. B. „created“, „repointed“, inkl. vorher/nachher recordable_type/_id). Das hält Audit-Trails und erlaubt Timeline-Features (siehe Video/37signals-Artikel).

Copy & Move: Subtrees kopieren

Ein Vorteil des Patterns: Kopieren und Verschieben ganzer Teilbäume wird planbar und schnell, weil Recordings leichtgewichtig sind und Recordables immutable dupliziert werden. Eine einfache Kopier-Serviceklasse:

class Copier
  def self.copy!(source_recording:, destination_bucket:, creator:)
    new(source_recording, destination_bucket, creator).copy!
  end

  def initialize(source_recording, destination_bucket, creator)
    @source_recording   = source_recording
    @destination_bucket = destination_bucket
    @creator            = creator
  end

  def copy!
    ActiveRecord::Base.transaction do
      copied_root = copy_recording(@source_recording, parent: nil)
      @source_recording.children.each { |child| copy_branch(child, parent: copied_root) }
      copied_root
    end
  end

  private

  def copy_branch(node, parent:)
    copied = copy_recording(node, parent: parent)
    node.children.each { |child| copy_branch(child, parent: copied) }
    copied
  end

  def copy_recording(original, parent:)
    new_recordable = duplicate_recordable(original.recordable)
    @destination_bucket.record(new_recordable, creator: @creator, parent: parent, color: original.color)
  end

  def duplicate_recordable(recordable)
    case recordable
    when Message
      Message.create!(title: recordable.title, content: recordable.content)
    when Document
      Document.create!(title: recordable.title, body: recordable.body, external_url: recordable.external_url)
    when Comment
      Comment.create!(body: recordable.body)
    else
      raise ArgumentError, "Unsupported recordable: #{recordable.class.name}"
    end
  end
end

Vergleich mit STI und „plain“ Polymorphismus

• STI: Einfache Fälle ok. Bei divergenten Typen entsteht Tabellen-Bloat, viele NULL-Spalten, Migrationen werden groß, Erweiterbarkeit leidet.
• Polymorphismus ohne delegated_type: Funktioniert, aber es fehlen bequeme Scopes/Convenience-Methoden; unified Pagination ist oft hakelig.
• Recordables + delegated_type: Einheitliche Timeline über eine dünne Tabelle, klare Trennung von Meta vs. Inhalt, leichte Erweiterbarkeit (neuen Typ hinzufügen statt zentrale Tabelle migrieren), gute Performance bei Abfragen.

Wann solltest du das Pattern nutzen?

• Du brauchst eine gemischte, paginierbare Timeline (z. B. Aktivitätsfeed über Messages, Documents, Comments).
• Deine Typen unterscheiden sich stark in ihren Attributen.
• Du willst Polymorphismus am Parent (Recording) und saubere Delegation an die Inhalte.

Wann eher nicht?

• Deine Subtypen sind fast identisch (STI könnte reichen).
• Du hast keine gemeinsamen Abfragen über Typgrenzen hinweg.

Best Practices

• Halte Recording schlank: nur Metadaten und die polymorphe Referenz. Keine großen Textfelder.
• Packe typenübergreifende Logik in Recording (oder Concerns), typenspezifische Logik in die Recordables.
• Nutze delegate am Recording für gemeinsame Schnittstellen, z. B. delegate :export_html, to: :recordable.
• Wenn Auditing/History wichtig ist, ergänze Events und schreibe Änderungen mit.
• Autorisierung: Recording bündelt viele Aktionen – prüfe Berechtigungen konsequent.

Fazit

Das Recordable Pattern mit delegated_type ist eine elegante, praxiserprobte Lösung für polymorphe Inhalte in Rails. Es bringt dir:

• eine einheitliche, performante Timeline,
• klare Verantwortlichkeiten zwischen Metadaten und Inhaltsobjekten,
• einfache Erweiterbarkeit ohne große Migrationen,
• saubere APIs durch Delegation.

Wenn du Feed-ähnliche Strukturen, Versionierung und Kopier-Features brauchst, wirst du mit Recordings/Recordables sehr schnell produktiv.

Viel Spaß beim Ausprobieren – und schreib mir gern, wenn du Fragen hast oder Beispiele aus deinem Projekt teilen willst!

— Mathias (webmatze.de)

Als Jugentlicher wollte ich unbedingt Turbo Pascal lernen und habe mir als Projekt ein einfaches Sokoban Spiel genommen und es umgesetzt. Im Laufe der Umsetzung habe ich vieles über Turbo Pascal gelernt und auch dessen Grenzen entdeckt. So musste ich z.B. einige der Grafikroutinen dann doch mit Assembler umsetzen.

Da mich das Programmieren von grafischen Spielereien (Demos) oder eben auch gleich richtigen Spielen schon immer faziniert hat, habe ich mich auch gleich für das DragonRuby Game Toolkit interessiert. Dieses erlaubt es euch, mit Hilfe der Ruby Programmiersprache 2D oder auch 3D Spiele zu programmieren.

Und da ich wieder nach einer Idee für ein Spiel suchte, dachte ich mir: "Hey, warum versucht du nicht einfach das gleiche Spiel wie damals umzusetzen?".

Gesagt – getan.

Also habe ich angefangen und entstanden ist dabei DragonRuby Sokoban.

Den Code findet ihr wie immer auf meinen GitHub Account.

Und wer es nicht erwarten kann, kann das Spiel auch gleich hier ausprobieren:

Viel Spaß!

Wenn man erst mal verstanden hat, wie diese funktionieren, weiß man was für ein mächtiges Werkzeug man damit in der Hand hat. Allerdings sind komplizierte Reguläre Ausdrücke nicht gerade einfach zu schreiben und zu testen.

Nun gibt es ein neues browserbasiertes Tool, mit dem sich Reguläre Ausdrücke sehr einfach und bequem schreiben und testen lassen.

ReFiddle (http://refiddle.com/) ist ganz ähnlich dem JavaScript Tool JsFiddle aufgebaut. Oben befindet sich ein Eingabefeld für den Regulären Ausdruck, darunter kann man einen beliebigen Text eingeben, auf den dieser Ausdruck angewendet werden soll.

Auf der Linken Seite lassen sich verschiedene Optionen einstellen um z.B. alle möglichen Treffer zu finden (Match all occurrences) oder um die Groß- und Kleinschreibung zu ignorieren (Ignore case). Außerdem lässt sich auswählen, für welche Sprache man den Regulären Ausdruck schreiben möchte. Momentan gibt es hier nur JavaScript, Ruby und .Net zur Auswahl.

Ich finde, dass ReFiddle das Zeug zu einem häufig genutzten Tool hat. Großartig ist, dass sich eigene erstellte Reguläre Ausdrücke mit anderen teilen lassen. Ich bin mir auch sicher, dass bald Unterstützung für weitere Sprachen folgen wird.

Was haltet ihr von diesem Tool? Werdet ihr es nutzen?

Ruby on Rails hingegen ist derzeit eines der populärsten und produktivsten OpenSource Frameworks, mit dem sich sehr schnell umfangreiche Webanwendungen erstellen lassen. Wer schon damit gearbeitet hat, weiß wieviel Spaß es machen kann.

Ruby selbst ist eine Scriptsprache, wie z.B. auch PHP eine Scriptsprache ist. Ruby wurde jedoch von Grund auf mit dem Ziel entwickelt, leicht verständlich zu sein und eine schnelle Entwicklung damit zu ermöglichen.

Ubuntu für Rails vorbereiten

Damit wir das Rails Framework unter Ubuntu 11.10 verwenden können, müssen wir zuerst Ruby installieren. Von Haus aus ist Ubuntu noch nicht mit Ruby ausgestattet, jedoch läßt sich dieses (und auch andere Programmiersprachen) sehr leicht nachträglich installieren.

Hierzu muss man wissen, dass es verschiedene Versionen von Ruby gibt. Ältere Versionen von Ruby on Rails haben hauptsächlich auf die Ruby Version 1.8.7 gesetzt. Die neusten Ruby on Rails Versionen ab 3.0 verwenden jedoch bevorzugt Ruby Version 1.9.2. Um unser System also für die Zukunft vorzubereiten, werden wir auf den Ruby Versions Manager (RVM) setzen, mit dem es möglich ist jede beliebige Ruby Version zu installieren und auch bequem zwischen diesen zu wechseln.

Damit wir RVM installieren können, müssen wir zuerst ein paar Abhängigkeiten installieren:

sudo apt-get install git
sudo apt-get install curl

Git benötigen wir, weil die meisten Ruby on Rails Projekte und Erweiterungen ihre Sourcen mit Git verwalten. Und curl brauchen wir, um mit dem folgenden Befehl RVM zu installieren:

bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

Nachdem dies ausgeführt wurde, bekommen wir noch ein paar Hinweise vom RVM Entwickler, wie wir damit umgehen können. Unter anderem wird auch noch darauf hingewiesen, dass folgende Abhängigkeiten installiert werden sollten, bevor man damit beginnen kann, ein oder mehrere Ruby Versionen zu installieren:

sudo apt-get install build-essential openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion

Nun sollte man das Terminal einmal schließen und wieder ein neues Terminal öffnen und mit folgenden Befehl überprüfen, ob RVM richtig installiert wurde:

type rvm | head -1

Wird hier jetzt 'rvm is a function' zurückgegeben, ist alles in Ordnung und wir können damit beginnen, unsere benötigte Ruby Version zu installieren.

Ruby 1.9.2 auf Ubuntu installieren

Abhängig davon, welche Ruby on Rails Version wir nutzen wollen, können wir nun die entsprechende Ruby Version installieren. Dies ist mit dem RVM Befehlt mehr als einfach. Gehen wir davon aus, dass wir Ruby on Rails 3.1 (also die aktuelle Version) installieren wollen, können wir so Ruby 1.9.2 installieren:

rvm install 1.9.2

Nach ein paar Minuten ist dann Ruby installieret. Beachten sollte man hierbei jedoch unbedingt, dass alles was man mit RVM macht ohne den sudo Befehlt ausgefürt werden muss! Warum dies so ist und weitere wichtige Nutzungshinweise erhaltet ihr in der RVM Dokumentation.

Um nun die installierte Ruby Version nutzen zu können, muss man sie mit dem folgenden Befehl aktivieren:

rvm use 1.9.2

Jetzt kann man überprüfen, welche Ruby Version installiert ist:

ruby -v

Ruby on Rails auf Ubuntu installieren

Nachdem nun alle notwendigen Vorbereitungen abgeschlossen sind, können wir damit beginnen die aktuelle Rails Version zu installieren. Rails und andere benötigte Packete werden mit dem RubyGems Package Manager installiert. Dieser wurde zum Glück auch schon automatisch von RVM mit installiert. Wir brauchen also nur noch folgendes auszuführen:

gem install rails

und schon wurde Ruby on Rails erfolgreich installiert. Auch hier ist wieder zu beachten, dass alle RubyGems ohne den sudo Befehl installiert werden.

JavaScript Runtime installieren

In der aktuellen Rails Version 3.1.1 gibt es noch eine weitere Abhängigkeit, welche man beachten muss. Rails benötigt hier nämlich eine im System installierte JavaScript Runtime um bestimmte Funktionen ausführen zu können. Am einfachsten und problemlosesten konnte ich dieses Problem bei mir beheben, indem ich Node.js installiert habe:

sudo apt-get install nodejs

Ruby on Rails testen

Jetzt wo alles installiert ist, können wir schnell noch ein Testprojekt mit Rails erstellen:

rails new test_app
cd test_app
rails server

und uns dies im Browser aufrufen:

http://localhost:3000

Fertig ist unsere Ruby on Rails installation auf Ubuntu.

Die hier genannten Installationsschritte mögen sich mit denen auf anderen Ubuntu Versionen oder anderen Linux System unterscheiden.