Creare manualmente controller e viste

In questa lezione implementiamo una funzionalità scrivendo il codice in prima persona. Il risultato che vogliamo ottenere è una pagina che elenchi tutti i bookmark cha abbiano un certo tag in comune

Partiamo avvantaggiati: nel database abbiamo già i dati di cui abbiamo bisogno (bookmark e tag) e il plugin ci fornisce i metodi per estrarre i bookmark associati ad un determinato tag.

Per prima cosa creiamo un controller dedicato, che chiameremo tags; dal terminale digitiamo:

$ ruby script/generate controller tags
   exists  app/controllers/
   exists  app/helpers/
   create  app/views/tags
   exists  test/functional/
   create  app/controllers/tags_controller.rb
   create  test/functional/tags_controller_test.rb
   create  app/helpers/tags_helper.rb

Con questo comando vengono aggiunti nuovi file al nostro progetto; in particolare:

• app/controllers/tags_controller.rb è il file che conterrà il codice del nuovo controller
• app/views/tags è la cartella che conterrà tutte le viste che andremo a creare per le azioni del controller

Apriamo il file app/controllers/tags_controller.rb e creiamo una nuova action definendo una funzione nella classe TagsController. Abbiamo visto che con l'istruzione Bookmark.find_tagged_with("Rails") si ottengono tutti i bookmark aventi il tag Rails; nel nostro caso dobbiamo ottenere il tag tramite un parametro, e quindi scriveremo:

class TagsController < ApplicationController
  def show
    # recupero il tag dal parametro :id
    @tag = params[:id] 
    # estraggo tutti i bookmark con il tag desiderato
    @bookmarks = Bookmark.find_tagged_with(@tag)
  end
end

L'action di cui abbiamo scritto il codice è identificata dai seguenti parametri:

• il controller tags
• l'action show
• il parametro id valorizzato con il tag che ci interessa (ad esempio "Rails")

La combinazione di questi parametri individua la action, qualsiasi sia il valore del parametro id, che cambia al cambiare del tag che ci interessa.

Per attivare il controller e la action che abbiamo appena scritto è necessario costruire il link che porti all'indirizzo corrispondente; per costruire questo indirizzo utilizzeremo il comando link_to, già visto in precedenza.

Questa volta il link deve attivare una action interna all'applicazione, e verrà costruito utilizzando i parametri che abbiamo appena elencato.

<%= link_to "Testo link", :controller => "tags", :action => "show", :id => "Rails" %>

Abbiamo già osservato che tutte le informazioni relative all'abbinamento fra url e action da attivare sono contenute nelle regole di routing del file config/routes.rb; queste regole non solo permettono di individuare controller, action e parametri a partire dall'URL, ma si possono utilizzare anche in senso inverso per costruire un URL a partire dall'indicazione di controller, action e parametri.

Il file config/routes.rb contiene, oltre alla regola per la risorsa Bookmark, alcune regole generiche che non si applicano ad una particolare risorsa:

ActionController::Routing::Routes.draw do |map|
  # regola per la risorsa bookmark
  map.resources :bookmarks
  ...
  # regole generiche
  map.connect ':controller/:action/:id'
  map.connect ':controller/:action/:id.:format'
end

Utilizzando le regole generiche il comando link_to produce un link del tipo /tags/show/rails, mettendo in fila i parametri controller, action e id. Quando clicchiamo un link di questo tipo, l'URL richiamato sarà interpretato per mezzo delle regole generiche e verranno individuati controller, action e parametri da invocare.

All'indirizzo http://0.0.0.0:3000/tags/show/rails attiviamo il controller tags, l'action show con il parametro id impostato a "rails"; l'action carica nella variabile @bookmark tutti i bookmark taggati con il tag "rails", e li rende disponibili alla vista.

Inseririamo il link per accedere a questa action nella vista di elenco dei bookmark, quindi nel file app/views/bookmarks/index.html.erb; al posto dell'istruzione che stampa a video tutti i tag relativi ad un singolo bookmark inseriamo questo frammento di codice:

<% for tag in bookmark.tag_list %>
  <%= link_to tag, :controller => "tags", :action => "show", :id => tag %>
<% end %>

Puntiamo il browser all'elenco dei bookmark, l'elenco dei tag è stato sostituito da un elenco di link a pagine differenti, ognuna dedicata ad un singolo tag. Cliccando su uno di questi link l'applicazione restituisce l'errore Template Missing, che ci ricorda che dobbiamo creare una vista per presentare il risultato finale in HTML.

Creiamo un nuovo file app/views/tags/show.html.erb e copiamo tutto il contenuto della vista app/views/bookmarks/index.html.erb nel file appena creato sostituendo il tag <h1> con:

<h1>Listing bookmarks with tag "<%= @tag %>"</h1>

Torniamo col browser all'elenco dei bookmark e clicchiamo su uno dei tag. Otteniamo tutti i bookmark che hanno quel tag in comune.

Creare nuove action e nuove viste senza l'utilizzo dello scaffold non è troppo complicato; cerchiamo di ripercorrere i passi da seguire per la creazione manuale di una pagina:

1. Se il controller che vogliamo utlizzare non esiste, creare il controller con il comando

   ruby scriptgenerate controller <nome_del_controller>

   cercando di dare un nome al controller significativo e aderente alle convenzioni di Rails

2. Definire l'azione all'interno del controller ed individuare i parametri necessari
3. Creare i link necessari a richiamare l'azione
4. Creare la vista per presentare il risultato finale della action

Dovendo aggiungere nuove funzionalità e quindi nuovo codice ad un'applicazione è sempre bene chiedersi quale strategia utilizzare:

• Generazione automatica del codice con scaffold - utile quando si deve implementare una gestione completa di una risorsa (creazione, modifica, lettura, cancellazione)
• Utilizzare un plugin - utile quando una funzionalità nella sua completezza è già stata sviluppata
• Scrivere codice manualmente - se si vuole implementare una funzionalità "non standard" e non esiste un plugin che la implementa

In questa seconda parte della guida, molto pratica, abbiamo tralasciato diversi aspetti importanti per comprendere il funzionamento di Rails. Li approfondiremo nelle prossime lezioni utilizzando come base l'applicazione appena realizzata.