Ruby on Rails Tutorial: Validazione dei Modelli

La validazione dei Modelli in Ruby on Rails permette di indicare a quali condizioni si possono salvare i dati sul database. La validazione riveste un ruolo molto importamente per assicurare l’integrità dei dati (ovvero essere certi che i dati introdotti in una applicazione abbiano senso).

Passiamo quindi alla definizione del modello rails, ovvero ‘come’ Ruby on Rails interagisce con la tabella del database che abbiamo appena creato; in particolare stabiliamo le regole di validazione del modello ovvero quando i dati inseriti per un determinato modello sono validi e si può quindi procedere al salvataggio dei dati sul database.

Apriamo il file app/models/link_url.rb

class LinkUrl < ActiveRecord::Base
end

La classe LinkUrl sarà il modo di accedere alla tabella link_urls del database (da notare come il nome del modello e della tabella siano stati generati automaticamente in modo da indicare che sono fra di loro collegati).

validates_presence_of: il parametro non può essere nullo

Per iniziare indichiamo che ogni url deve evere url, title, description e votes non nulli


class LinkUrl < ActiveRecord::Base
  # Controllo presenza attributo url
  validates_presence_of :url,
    :message => "Url non presente - specificare un URL"
  # Controllo presenza attributo title
  validates_presence_of :title,
    :message => "Titolo non presente - specificare un titolo"
  # Controllo la presenza degli attributi description e votes
  validates_presence_of :description,
    :message => "Descrizione non presente - specificare la descrizione"
  validates_presence_of :votes,
    :message => "Voti non presente"
end

Per ognuno degli attributi che ci interessa controllare abbiamo indicato di controllarne la presenza, e abbiamo inoltre specificato un messaggio di errore con :message =>; il messaggio di errore si rivelerà molto utile per dare un feedback sensato all’utente relativamente a cosa è andato storto nella validazione dei dati che ha inserito.

validates_length_of: il parametro ha una lunghezza massima

Definiamo ora la lunghezza massima in numero di caratteri che ogni attributo può raggiungere; dal momento che i dati che saranno inseriti andranno a finire all’interno del detabase, è importante controllare che il dato possa essere fisicamente ospitato nella relativa colonna.


class LinkUrl < ActiveRecord::Base
  # Controllo presenza attributo url
  validates_presence_of :url,
    :message => "Url non presente - specificare un URL"
  validates_length_of :url, :maximum => 255,
    :message => "URL troppo lungo"
   [...]
end

Con validates_length_of abbiamo indicato quale può essere la lunghezza massima del parametro url, e sempre con :message => è stat indicato il messaggio da visualizzare all’utente.

validates_numericality_of: il parametro deve essere un numero

Il modello LinkUrl possiede il parametro votes che tiene il conto di quanti voti positivi un determinato link ha raccolto; votes dovrà quindi essere un numero, e non sarà accettabile assegnare a quel parametro un valore del tipo "Tanti voti". Aggiungiamo quindi una validazione che si assicuri che il parametro possa assumere solo valori numerici.


class LinkUrl < ActiveRecord::Base
   [...]
  validates_numericality_of :votes,
    :message => "votes deve essere un numero"
   [...]
end

Nel nostro caso vogliamo qualcosa di più; il fatto che sia un numero non ci basta, questo numero deve essere intero: ha infatti senso dire che un link ha ricevuto 3 voti, non ha significato invece dire che ne ha ricevuti 3.5. Ruby on Rails permette di specificare questa richiesta aggiungendo all’istruzione il parametro :only_integer => true.

validates_uniqueness_of: il parametro deve essere univoco

Nella nostra applicazione di esempio gli URL potranno essere inseriti da persone differenti; è quindi più che probabile che diverse persone vogliano segnalare lo stesso URL, ma nell’economia dell’applicazione questo non deve essere possibile. E’ quindi necessario indicare tramite la validazione che un URL non può essere inserito all’interno del sistema più di una volta.


class LinkUrl < ActiveRecord::Base
  # Controllo presenza attributo url
  validates_presence_of :url,
    :message => "Url non presente - specificare un URL"
  validates_length_of :url, :maximum => 255,
    :message => "URL troppo lungo"
  validates_uniqueness_of :url,
    :message => "URL presente nel sistema"
   [...]
end

L’utilizzo di validates_uniqueness_of ricorda molto da vicino l’istruzione SQL che indica l’unicità di un valore per una intera colonna.

Validazione dei modelli in Ruby on Rails

Abbiamo visto come Ruby on Rails permette di definire la validazione dei modelli in modo pratico con l’aiuto di alcune istruzioni da aggiungere all’interno del modello. In questo tutorial non sono presentate tutte le potenzialità della validazione in Ruby on Rails; per approfondimenti rimando alla documentazione del modulo ActiveRecord::Validations::ClassMethods.

Un altro aspetto molto importante relativamente alla protezione dei dati tramite la validazione è la definizione di regole di validazione personalizzate, sia concentrate sul singolo modello sia quelle che investono differenti modelli o risorse esterne all’applicazione (nel nostro esempio, si potrebbe definire una validazione che considera non validi tutti i link che sono suggeriti e che sono in presenti nella home page di digg o di reddit).