La creazione dell'applicazione

Possiamo ora passare alla creazione dell'applicazione, come abbiamo già visto in precedenza, tramite il comando Rails hforum. Dopo averlo fatto usiamo script/generate model per creare i modelli per tutte e tre le tabelle (ricordate di modificare config/database.yml se non usate la stessa configurazione di questo articolo) . 

Ora però ci troviamo di fronte ad un problema: come rappresentare le relazioni che hanno tra loro gli oggetti? Sappiamo che un messaggio corrisponde ad un autore, e ad un topic, ma ActiveRecord non ha modo di sapere se queste relazioni siano effettivamente tra uno ed uno o tra uno e molti. 

Poiché dunque le capacità di mappatura automatica del database non sono più sufficienti, dobbiamo cominciare a scrivere del codice. Fortunatamente, questo codice è molto semplice: modifichiamo le classi in modo che risultino fatte in questo modo

has_many :messages significa "ha molti messaggi", cioè ad un autore sono collegati N messaggi. Questo metodo farà si che per gli oggetti Author ci sia un attributo messages che restituisce una lista di messaggi.

belongs_to :author  significa che  un messaggio appartiene ad un autore. In un certo senso si tratta della relazione inversa alla precedente. In questo caso verrà creato un attributo author per gli oggetti Message che permetterà di risalire all'autore. Ovviamente, lo stesso discorso vale per belongs_to :topic.

Anche in questo caso, una relazione  uno a molti, vale il discorso fatto in precedenza.

Non abbiamo fatto altro che usare il linguaggio di dominio definito da ActiveRecord per esprimere in uno stile vicino alla lingua inglese quello che avevamo detto prima. Notate come singolare e plurale vengano usati in modo da massimizzare la similitudine linguistica. Ma cosa fanno di preciso questi metodi? Essi generano degli attributi virtuali, che permettono di lavorare direttamente con gli oggetti senza preoccuparsi della loro rappresentazione. Vediamo un veloce esempio usando ancora script/console, in rosso indichiamo sempre i comandi scritti da noi a mano:

>> pippo=Author.new(:name=>"pippo", :password=>"segreta")
=> #<Author:0x3964798 @new_record=true, @attributes={"name"=>"pippo", "password"=>"segreta"}>
>> topic=Topic.new(:title=>"Benvenuti!")
=> #<Topic:0x3961210 @new_record=true, @attributes={"updated_at"=>nil, "title"=>"Benvenuti!"}>
>> message=Message.new(:body=>"Il primo messaggio nel nostro forum")
=> #<Message:0x395cb48 @new_record=true, @attributes={"topic_id"=>0, "body"=>"Il primo messaggio nel nostro forum", "author_id"=>0, "created_at"=>nil}>
>> message.topic= topic
=> #<Topic:0x3961210 @new_record=true, @attributes={"updated_at"=>nil, "title"=>"Benvenuti!"}>
>> message.author= pippo
=> #<Author:0x3964798 @new_record=true, @attributes={"name"=>"pippo", "password"=>"segreta"}>
>> message.save
=> true
>> pippo.messages
=> [#<Message:0x39476b0 @attributes={"topic_id"=>"1", "body"=>"Il primo messaggio nel nostro forum", "id"=>"1", "author_id"=>"1", "created_at"=>"2006-06-11 22:31:32"}>]

La prima cosa che vediamo è la possibilità di passare dei parametri al metodo new in modo da inizializzare facilmente gli attributi. La sintassi è oggetto=>valore ed è la sintassi che si usa in Ruby per definire un Hash, o dizionario, in cui il primo elemento è la chiave ed il secondo il valore. In questo caso la chiave è un simbolo, anche se in realtà in Ruby è possibile usare un oggetto qualunque.

In seguito, assegniamo gli oggetti di classe Topic e Author agli attributi del messaggio, e possiamo vedere che automaticamente vengono aggiornati i loro attributi. Poiché un autore ed un topic hanno molti messaggi, l'attributo non è message ma messages, ed è un Array.

Un metodo equivalente per collegare le entità sarebbe stato di prendere l'oggetto che rappresenta il messaggio ed aggiungerlo all'array tramite l'operatore "<<":

Il vantaggio di usare queste strutture collegate è che ora salvando il messaggio automaticamente salviamo anche gli oggetti connessi, se ancora non lo sono:

>> message.save
=> true
>> Topic.find_first.messages
=> [#<Message:0x3987550 @attributes={"topic_id"=>"1", "body"=>"Il primo messaggio nel nostro forum", "id"=>"1", "author_id"=>"1", "created_at"=>"2006-06-11 22:31:32"}>]

Oltre alle relazioni uno-uno ed uno-molti che abbiamo visto, esiste anche la possibilità di realizzare associazioni molti-molti tramite il metodo has_and_belongs_to_many, che funziona in maniera leggermente differente. 

Infatti per associare dei record in questa configurazione è necessario avere una join table, ovvero una tabella composta da due campi che contengono foreign key verso gli id degli oggetti. C'è una convenzione sul nome della tabella, ovvero seguire lo schema primatabella_secondatabella, ma visto che nel nostro esempio non ne avremo bisogno siete invitati a leggere la documentazione di Rails per maggiori dettagli.

Infine, parliamo dei metodi find_qualcosa. Oltre ai già visti find_all e find_first, il cui significato dovrebbe essere ovvio, è possibile utilizzare Modello.find. Questo metodo è in realtà quello consigliato in quanto può svolgere non solo le funzionalità dei due già visti, ma molte altre. 

In particolare, usando i simboli come parole chiave si può scrivere

• Model.find( :first): recupera il primo elemento
• Model.find( :all): recupera tutti gli elementi

Ma è anche possibile cercare un elemento tramite il suo id

• Model.find( 12): restituisce l'elemento con id uguale a 12
• Model.find(1,23, 456): restituisce gli elementi con id 1, 23, 456

e molte altre possibilità, incluso il passare SQL direttamente. Di nuovo, siete invitati a leggere la documentazione di Rails per scoprire tutte le potenzialità di questo metodo.

Infine, la cosa più interessante è la possibilità di ricercare tramite dei metodi creati dinamicamente a seconda degli attributi della tabella, quindi ad esempio potremo cercare un Topic tramite il suo titolo con Topic.find_by_title("titolo") e addirittura avere ricerche incrociate con metodi come Model.find_by_qualcosa_and_qualcosaltro_and_altroancora(a, b, c).