Architettura
4.3 Rails
4.3.1 Struttura cartelle applicativi Rails
Figura 4.6. Alberatura di Rails
Le applicazioni sviluppate in Rails sono organizzate come un insieme di sottocartelle (figura 4.6). Seguendo questa struttura, è possibile comprendere con semplicità il codice di progetti realizzati da altri, oltre a poter rendere automatica la generazione di codice.
Le sotto cartelle hanno questo significato [10]:
• app: è il nucleo centrale dell’applicazione; essendo Rails un framework MVC, le tre sezioni Model, View e Controller vanno all’interno di questa directory.
• app/assets: contiene i file richiesti per il front-end dell’applicazione; questi file sono raggruppati in base al tipo (images, javascripts, css, ecc...). All’interno di questa cartella ci sono due file in particolare che assumono un ruolo particolare: javascrip-ts/application.js e scss/application.css e sono due file di tipo "manifest". In questi file devono essere inseriti tutti i riferimenti di tutti i file javascript/css utilizzati che verranno unificati e minimizzati prima di essere inviati alla componente view.
Porzione di aplication.js
1 // E s t r a t t o di a p p l i c a t i o n . js
2 //= r e q u i r e b o o t s t r a p / b o o t s t r a p
3
4 // J A R V I S W I D G E T S
5 //= r e q u i r e s m a r t w i d g e t s / j a r v i s . w i d g e t
6
7 // D A T A T A B L E P L U G I N
8 //= r e q u i r e p l u g i n / d a t a t a b l e s / j q u e r y . d a t a T a b l e s
9 //= r e q u i r e p l u g i n / d a t a t a b l e s / d a t a T a b l e s . c o l V i s
10 //= r e q u i r e p l u g i n / d a t a t a b l e s / d a t a T a b l e s . t a b l e T o o l s
11 //= r e q u i r e p l u g i n / d a t a t a b l e s / d a t a T a b l e s . b o o t s t r a p
12 //= r e q u i r e p l u g i n / d a t a t a b l e - r e s p o n s i v e / d a t a t a b l e s . r e s p o n s i v e
13
14 // J Q U E R Y S E L E C T 2 I N P U T
15 //= r e q u i r e p l u g i n / s e l e c t 2 / s e l e c t 2
16
17 // j Q u e r y A u t o c o m p l e t e
18 //= jquery - ui / w i d g e t s / a u t o c o m p l e t e . js
19 //= r e q u i r e modal - r e s p o n d e r . js
20
21 //= r e q u i r e s a n H e l p e r . js
• app/controllers: contiene i file richiesti per i controller che gestiscono i model e le view. Per seguire le convenzioni di Rails, i nomi dei file che descrivono un troller seguono lo "snake case" e sono composti dal nome del model al plurale con-catenato a "_controller.rb". Ad esempio il controller per il model Folder sarà fol-ders_controller.rb. Inoltre, il nome della classe seguirà il "CamelCase" e sarà, ad esempio, FoldersController.
Porzione di folders_controller.rb
1 c l a s s F o l d e r s C o n t r o l l e r < G u i C o n t r o l l e r
2 # ...
3 # c o d i c e
4 # ...
5 p r i v a t e
6 def v a l i d a t e _ p a r a m s
7 v a l i d a t e d _ p a r a m s = p a r a m s . r e q u i r e (: f o l d e r ) . p e r m i t !. t o _ h
8 v a l i d a t e d _ p a r a m s
9 end
10 def g e t _ r e c o r d
11 @ i s R e m i n d e r = p a r a m s [: r e m i n d e r ] ? t r u e : f a l s e
12 rec = F o l d e r . f i n d ( p a r a m s [: id ])
13 g e t _ r e l a t e d _ r e c o r d rec
14 end
15
16 def g e t _ r e c o r d s e t
17 @ r e c o r d s e t d i m = F o l d e r . w h e r e .not( e n d _ d a t e : nil) # d i m e s s i
18 F o l d e r . w h e r e ( e n d _ d a t e : nil)
19 end
20 # ...
21 # a l t r o c o d i c e
22 # ...
23 end
Tra tutti i controller, quello principale è ApplicationController e da questo ereditano tutti gli altri. Tutti i metodi definiti al suo interno sono disponibili a tutti i controller.
• app/helpers: in questa cartella risiedono tutte le funzioni di supporto per le view;
sono a disposizione una serie di helper di default come ad esempio image_tag per refe-renziare le immagini nelle view; possono essere create funzioni in un file helper specifi-co del specifi-controller seguendo la specifi-convenzione di denominazione nome_specifi-controller_helper.
Di default esiste l’helper generale application_helper: i metodi scritti in questo helper sono disponibili in tutti gli altri helper e in tutte le view.
• app/models: in questa cartella sono presenti tutti i file relativi ai model; il mo-del agisce come mappatore degli oggetti relazionali per le tabelle mo-del database. La convenzione sui nomi è semplicemente nomedelmodel.rb e il nome del model è per convenzione la forma singolare del nome della tabella in database. Ad esempio Folder sarà il model che mapperà la tabella folders in database.
Qui vengono gestite anche le associazioni tra le varie tabelle. In Rails, un’associazione è una connessione tra due ActiveRecord [11]. Le associazioni utilizzate nel progetto sono le seguenti:
– belongs_to: imposta una connessione uno-a-uno con un altro model, in modo tale che ogni istanza del model dichiarante appartenga a un’istanza dell’altro model. Ad esempio il model Fut, che può appartenere solo a una cartella, avrà un belongs_to al model Folder (figura 4.7).
Figura 4.7. Associazione belongs to
– has_one: anche questa è una connessione uno-a-uno con un altro model ma con semantica e conseguenze leggermente diverse. Indica che ogni istanza di un model contiene o possiede un altro model. Ad esempio il model Folder può avere una istanza del model NextAnamnesis.
– has_many: indica una connessione uno-a-molti con un altro model. Molto spes-so nell’altro model verrà indicata anche l’asspes-sociazione belongs_to. Con questa associazione si può indicare che ogni istanza del model ha zero o più istanze di un altro model. Ad esempio il model Warfarin può avere zero o più istanze di WarfarinRow e quest’ultimo avrà una sola istanza del model Warfarin.
– has_many :through: viene utilizzata per impostare connessioni molti-a-molti con un altro model. Indica che il model dichiarante può essere collegato a zero o
più istanze di un altro model passando attraverso un terzo model. Ad esempio il model Delivery può avere zero o più istanze di Role passando attraverso la relazione DeliveryRole (figura 4.8).
Figura 4.8. Associazione has many :through
• app/views: all’interno di questa cartella vanno a finire tutti i file che riguardano la terza parte del MVC, le view. I file sono una combinazione di HTML e Ruby (nomi-nato Embedded Ruby o Erb) e sono organizzati in base al controller corrispondente.
Seguendo le convenzioni di Rails, deve esistere una view per ogni azione del controller:
ad esempio per l’azione FoldersController#index deve esistere la corrispondente view app/views/folders/index.html.erb.
All’interno di questa cartella, ne esiste una che contiene i layout ereditati da tutte le view. Possono essere creati diversi layout per diversi ambiti dell’applicazione.
Contenuto del layout _header.html.erb
1 < h e a d e r id =" h e a d e r ">
2 < div id =" logo - g r o u p ">
3 < a h r e f =" / ">
4 < s p a n id =" l o g o "> <%= i m a g e _ t a g " l o g o . png "% > </ span >
5 </ a >
6 </ div >
7 <%= y i e l d : t o p _ r i g h t % >
8 <% if c u r r e n t _ u s e r && ! @ s i m u l a t e _ n o _ u s e r % >
9 < div c l a s s=" pull - r i g h t ">
10 < div id =" hide - m e n u " c l a s s=" btn - h e a d e r ␣ pull - r i g h t ">
11 < span >
12 < a h r e f =" j a v a s c r i p t : v o i d (0) ; " data - a c t i o n =" t o g g l e M e n u ">
13 < i c l a s s=" fa ␣ fa - r e o r d e r "> </ i >
14 </ a >
15 </ span >
16 </ div >
17 < div id =" l o g o u t " c l a s s=" btn - h e a d e r ␣ pull - r i g h t ">
18 < span >
19 <%= l i n k _ t o ( d e s t r o y _ u s e r _ s e s s i o n _ p a t h ) do % >
20 < i c l a s s=" fa ␣ fa - sign - out "> </ i >
21 <% end % >
22 </ span >
23 </ div >
24 <! - - f u l l s c r e e n b u t t o n - - >
25 < div id =" f u l l s c r e e n " c l a s s=" btn - h e a d e r ␣ pull - r i g h t ">
26 < span >
27 < a h r e f =" j a v a s c r i p t : v o i d (0) ; " data - a c t i o n =" F u l l s c r e e n ">
28 < i c l a s s=" fa ␣ fa - arrows - alt "> </ i >
29 </ a >
30 </ span >
31 </ div >
32 </ div >
33 <! - - end p u l l e d r i g h t : nav a r e a - - >
34 <% end % >
35 </ header >
• bin: contiene i Binstubs per le applicazioni Rails. I Binstubs sono dei wrapper per eseguire le gem dell’applicazione (pacchetti di programmi e librerie scritte in Ruby).
Quelli disponibili di default sono bundle, rails, rake, setup e spring.
• config: come il nome suggerisce, contiene i file di configurazione dell’applicazione.
L’ambiente applicativo può essere manipolato dai file all’interno di questa cartella. È necessario scendere nel dettaglio per scoprire meglio cosa fanno alcuni di questi file e cartelle:
– application.rb: contiene le configurazioni principali dell’applicazione come il timezone e la lingua utilizzata di default; le configurazioni presenti in questo file sono valide per tutti gli ambienti (sviluppo, test e produzione).
– application.yml: contiene le variabili d’ambiente disponibili tramite l’array associativo ENV.
– boot.rb: come si può immaginare, questo file è necessario per permettere l’avvio dell’applicazione. Le applicazioni Rails mantengono le dipendenze dalle gem al-l’interno del file Gemfile nella cartella root del progetto. Il Gemfile è obbligatorio
e boot.rb si occupa di verificare la sua presenza e salva il percorso verso questo file in una variabile d’ambiente chiamata BUNDLE_GEMFILE per usi futuri.
– database.yml: in questo file sono presenti le configurazioni per i database dei tre ambienti menzionati precedentemente (sviluppo, test e produzione).
Porzione di database.yml per l’ambiente di sviluppo
1 d e f a u l t : & d e f a u l t
2 a d a p t e r : p o s t g r e s q l
3 e n c o d i n g : u n i c o d e
4 p o o l : <%= ENV . f e t c h (" R A I L S _ M A X _ T H R E A D S ") { 5 } % >
5
6 d e v e l o p m e n t :
7 < <: * d e f a u l t
8 d a t a b a s e : m e d r e c _ d e v
9 u s e r n a m e : m e d r e c
10 p a s s w o r d : <%= ENV [" M E D R E C _ D A T A B A S E _ P A S S W O R D "] % >
Per questo progetto, come si può vedere dall’estratto di codice del file in esame, è stato scelto di utilizzare come motore di database PostgreSQL. Questo è un potente sistema di database relazionale, orientato agli oggetti, open source e che utilizza ed estende le funzionalità del linguaggio SQL [12]. È molto conosciuto nell’ambiente grazie alla sua architettura, affidabilità, integrità dei dati, set di funzionalità ed estensibilità.
– environment.rb: questo file, di concerto con application.rb permette di inizia-lizzare l’applicazione Rails.
– routes.rb: all’interno di questo file sono presenti le rotte dell’applicazione.
Porzione di routes.rb
1 R a i l s . a p p l i c a t i o n . r o u t e s . d r a w do
2 r o o t " m i s c e l l a n e o u s # b l a n k _ p a g e "
3 get " m i s c e l l a n e o u s / l o g i n ",
4 to : " m i s c e l l a n e o u s # l o g i n ",
5 as : : m i s c e l l a n e o u s _ l o g i n
6 r e s o u r c e s : f o l d e r s do
7 r e s o u r c e s : p e r m i s s i o n s
8 end
9 r e s o u r c e s : p r i n t s
10 r e s o u r c e s : u s e r s
11 r e s o u r c e s : r o l e s
12 p o s t " api / f o l d e r s / c r e a t e ",
13 to : " a p i _ f o l d e r s # c r e a t e ", as : : a p i _ f o l d e r _ c r e a t e
14 p o s t " api / f o l d e r s / u p d a t e ",
15 to : " a p i _ f o l d e r s # u p d a t e ", as : : a p i _ f o l d e r _ u p d a t e
16 end
– environments: questa cartella contiene i file di configurazione specifici per gli ambienti a disposizione (sviluppo, test e produzione).
– initializers: è una cartella che contiene tutti i file che devono essere eseguiti durante l’inizializzazione di Rails. Tutti i file *.rb presenti all’interno di que-sta cartella vengono eseguiti automaticamente in maniera sequenziale alfabetica, grazie al comando Rails.application.initialize! presente in config/environment.rb.
• db: tutti i file relativi al database vanno a finire in questa cartella (file di migrazione, schema, configurazione e seed).
• lib: raccoglie le librerie specifiche dell’applicazione. I file presenti in questa cartella sono estratti di codice riutilizzabile, include la sottocartella tasks che colleziona i Ra-ke tasks richiesti dai RaRa-kefile; i RaRa-kefile sono invocati tramite Rails.application.load_
tasks e richiedono application.rb.
1 # t a s k per la c r e a z i o n e d e l l e s o m m i n i s t r a z i o n i in m a n i e r a
2 # p r o g r a m m a t i c a . V i e n e e s e g u i t o sul s e r v e r o g n i g i o r n o a l l e
3 # 0 0 : 0 1 per p o t e r a v e r e a d i s p o s i z i o n e le s o m m i n i s t r a z i o n i
4 # del g i o r n o c o r r e n t e . E s e c u z i o n e t r a m i t e il c o m a n d o
5 # b u n d l e e x e c r a k e c r e a t e _ f u t _ a d m i n s : c r e a t e
6 n a m e s p a c e : c r e a t e _ f u t _ a d m i n s do
7 d e s c " C r e a t e ␣ fut ␣ a d m i n s ␣ for ␣ all ␣ h o s p i t a l i z e d ␣ p a t i e n t s "
8 t a s k : create , [] = > [: e n v i r o n m e n t ] do | t , a r g s |
9 p u t s " S t a r t ␣ #{ D a t e T i m e . now } "
10 F o l d e r . w h e r e ( e n d _ d a t e : nil) . e a c h do | f o l d e r |
11 a c t i v e _ f u t = f o l d e r . f u t s . f i n d _ b y ( s t a t e : 1)
12 w a r f a r i n = f o l d e r . w a r f a r i n s . f i n d _ b y ( s t a t e : 1)
13 d = D a t e . t o d a y
14 n = D a t e T i m e . now
15 f u t _ a d m i n s = F u t P l u g i n H e l p e r . g e t _ t o d a y _ f u t _ a d m i n s (
16 folder , a c t i v e _ f u t , w a r f a r i n , false, d , n , n )
17 p u t s " F o l d e r ␣ #{ f o l d e r . n u m b e r }: ␣ #{ f u t _ a d m i n s . c o u n t } "
18 end
19 p u t s " End ␣ #{ D a t e T i m e . now } "
20 end
21 end
• plugins: questa cartella raccoglie tutti i plugin dell’applicazione. I plugin di Rails sono estensioni o modifiche al nucleo dell’applicazione [13]. Forniscono: un modo per condividere idee innovative senza danneggiare il codice base dell’applicativo; un’ar-chitettura segmentata in modo da poter aggiornare singole funzionalità in base alle proprie pianificazioni di rilascio; un modo per non includere tutte le funzionalità del-l’applicativo e poter eseguire installazioni modulari in base alle richieste del cliente.
Rails fornisce la possibilità di creare plugin come delle gem, gemified plugins. Gli sviluppatori di SAN hanno scelto di seguire un metodo differente messo a disposizione dal progetto Redmine.