Ruby on Rails - Guida rapida

Cos'è Ruby?

Prima di cavalcare su Rails, ricapitoliamo alcuni punti di Ruby, che è la base di Rails.

Ruby è la combinazione vincente di -

L'eleganza concettuale di Smalltalk,
La facilità d'uso e di apprendimento di Python e
Il pragmatismo di Perl.

Ruby è -

Un linguaggio di programmazione di alto livello.
Interpretato come Perl, Python, Tcl / TK.
Orientato agli oggetti come Smalltalk, Eiffel, Ada, Java.

Perché Ruby?

Ruby è nato in Giappone e ora sta guadagnando popolarità anche negli Stati Uniti e in Europa. I seguenti fattori contribuiscono alla sua popolarità:

Facile da imparare
Open source (licenza molto liberale)
Biblioteche ricche
Molto facile da estendere
Veramente orientato agli oggetti
Meno codifica con meno bug
Comunità utile

Sebbene abbiamo molte ragioni per usare Ruby, ci sono anche alcuni inconvenienti che potresti dover considerare prima di implementare Ruby:

Performance Issues - Anche se rivaleggia con Perl e Python, è ancora un linguaggio interpretato e non possiamo confrontarlo con linguaggi di programmazione di alto livello come C o C ++.
Threading model- Ruby non utilizza thread nativi. I thread Ruby vengono simulati nella VM anziché essere eseguiti come thread del sistema operativo nativo.

Esempio di codice Ruby

Ecco un esempio di codice Ruby per stampare "Hello Ruby"

# The Hello Class
class Hello
   
   def initialize( name )
      @name = name.capitalize
   end

   def salute
      puts "Hello #{@name}!"
   end
   
end

# Create a new object
h = Hello.new("Ruby")

# Output "Hello Ruby!"
h.salute

Output - Questo produrrà il seguente risultato:

Hello Ruby!

Rubino incorporato

Ruby fornisce un programma chiamato ERB (Embedded Ruby), scritto da Seki Masatoshi . ERB ti consente di inserire codici Ruby all'interno di un file HTML. ERB legge, parola per parola, e poi a un certo punto, quando incontra un codice Ruby incorporato nel documento, inizia a eseguire il codice Ruby.

Devi sapere solo due cose per preparare un documento ERB:

Se vuoi che venga eseguito del codice Ruby, racchiudilo tra <% e %>.
Se si desidera che il risultato dell'esecuzione del codice venga stampato, come parte dell'output, racchiudere il codice tra <%= e %>.

Ecco un esempio. Salva il codice nel file erbdemo.rb. Nota che un file Ruby avrà un'estensione.rb -

<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>

<html>

   <head>
      <title><%= page_title %></title>
   </head>
	
   <body>
      <p><%= salutation %></p>
      <p>This is an example of how ERB fills out a template.</p>
   </body>
	
</html>

Ora, esegui il programma utilizzando l'utilità della riga di comando erb.

tp> erb erbdemo.rb

Questo produrrà il seguente risultato:

<html>

   <head>
      <title>Demonstration of ERb</title>
   </head>
	
   <body>
      <p>Dear programmer,</p>
      <p>This is an example  of how ERb fills out a template.</p>
   </body>
	
</html>

Cos'è Rails?

Un framework per applicazioni web estremamente produttivo.
Scritto in Ruby da David Heinemeier Hansson.
Potresti sviluppare un'applicazione web almeno dieci volte più velocemente con Rails di quanto potresti sviluppare con un tipico framework Java.
Un framework Ruby open source per lo sviluppo di applicazioni web basate su database.
Configura il tuo codice con lo schema del database.
Nessuna fase di compilazione richiesta.

Framework a stack completo

Include tutto il necessario per creare un'applicazione Web basata su database, utilizzando il pattern Model-View-Controller.
Essendo un framework full-stack significa che tutti i livelli sono costruiti per funzionare perfettamente insieme con meno codice.
Richiede meno righe di codice rispetto ad altri framework.

Convenzione sulla configurazione

Rails evita i file di configurazione a favore di convenzioni, reflection e estensioni dinamiche di runtime.
Il codice dell'applicazione e il database in esecuzione contengono già tutto ciò che Rails ha bisogno di sapere!

Punti di forza delle rotaie

Rails è ricco di funzionalità che ti rendono più produttivo, con molte delle seguenti funzionalità che si integrano l'una sull'altra.

Metaprogrammazione

Laddove altri framework utilizzano un'estesa generazione di codice da zero, Rail framework utilizza tecniche di metaprogrammazione per scrivere programmi. Ruby è uno dei migliori linguaggi per la metaprogrammazione e Rails utilizza bene questa capacità. Anche Rails utilizza la generazione del codice, ma si basa molto di più sulla metaprogrammazione per il lavoro pesante.

Record attivo

Rails introduce il framework Active Record, che salva gli oggetti nel database. La versione Rails dell'Active Record scopre le colonne in uno schema di database e le allega automaticamente agli oggetti del tuo dominio usando la metaprogrammazione.

Convenzione sulla configurazione

La maggior parte dei framework di sviluppo web per .NET o Java ti obbliga a scrivere pagine di codice di configurazione. Se segui le convenzioni di denominazione suggerite, Rails non necessita di molta configurazione.

Impalcatura

Spesso si crea codice temporaneo nelle prime fasi dello sviluppo per ottenere rapidamente un'applicazione e vedere come interagiscono i componenti principali. Rails crea automaticamente la maggior parte delle impalcature di cui avrai bisogno.

Test integrato

Rails crea semplici test automatizzati che puoi estendere. Rails fornisce anche codice di supporto chiamato harness e fixtures che rendono i casi di test più facili da scrivere ed eseguire. Ruby può quindi eseguire tutti i tuoi test automatizzati con l'utility rake.

Tre ambienti

Rails ti offre tre ambienti predefiniti: sviluppo, test e produzione. Ciascuno si comporta in modo leggermente diverso, semplificando l'intero ciclo di sviluppo del software. Ad esempio, Rails crea una nuova copia del database Test per ogni esecuzione di test.

Per sviluppare un'applicazione web utilizzando Ruby on Rails Framework, è necessario installare il seguente software:

Ruby
Il framework Rails
Un server web
Un sistema di database

Partiamo dal presupposto che abbiate già installato un Web Server e un Database System sul vostro computer. Puoi usare WEBrick Web Server, fornito con Ruby. La maggior parte dei siti Web tuttavia utilizza server Web Apache o lightTPD in produzione.

Rails funziona con molti sistemi di database, inclusi MySQL, PostgreSQL, SQLite, Oracle, DB2 e SQL Server. Fare riferimento al corrispondente manuale di configurazione del sistema database per configurare il database.

Diamo un'occhiata alle istruzioni di installazione per Rails su Windows e Linux.

Installazione di Rails su Windows

Segui i passaggi indicati di seguito per l'installazione di Ruby on Rails.

Passaggio 1: controlla la versione di Ruby

Innanzitutto, controlla se hai già installato Ruby. Apri il prompt dei comandi e digitaruby -v. Se Ruby risponde e se mostra un numero di versione uguale o superiore a 2.2.2, digitagem --version. Se non ricevi un errore, saltaInstall Rubypasso. Altrimenti, installeremo un nuovo Ruby.

Passaggio 2: installa Ruby

Se Ruby non è installato, scarica un pacchetto di installazione da rubyinstaller.org. Segui ildownloadlink ed esegui il programma di installazione risultante. Questo è un file exerubyinstaller-2.2.2.x.exee verrà installato con un solo clic. È un pacchetto molto piccolo e riceverai anche RubyGems insieme a questo pacchetto. Si prega di controllareRelease Notes per maggiori dettagli.

Passaggio 3: installazione di Rails

Install Rails - Con Rubygems caricato, puoi installare tutti i Rails e le sue dipendenze usando il seguente comando tramite la riga di comando -

C:\> gem install rails

Note- Il comando precedente potrebbe richiedere del tempo per installare tutte le dipendenze. Assicurati di essere connesso a Internet durante l'installazione delle dipendenze gems.

Passaggio 4: verifica della versione di Rails

Utilizzare il seguente comando per verificare la versione dei binari.

C:\> rails -v

Output

Rails 4.2.4

Congratulazioni! Ora sei su Rails su Windows.

Installazione di Rails su Linux

Stiamo installando Ruby On Rails su Linux usando rbenv. È uno strumento di gestione delle versioni di Ruby leggero. Ilrbenv fornisce una semplice procedura di installazione per gestire varie versioni di Ruby e un ambiente solido per lo sviluppo di applicazioni Ruby on Rails.

Segui i passaggi indicati di seguito per installare Ruby on Rails utilizzando lo strumento rbenv.

Passaggio 1: installa le dipendenze dei prerequisiti

Prima di tutto, dobbiamo installare git - coree alcune dipendenze ruby che aiutano a installare Ruby on Rails. Usa il seguente comando per installare le dipendenze di Rails usandoyum.

tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-devel

Passaggio 2: installa rbenv

Ora installeremo rbenv e imposteremo le variabili d'ambiente appropriate. Usa il seguente set di comandi per ottenere rbenv per il repository git.

tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile tp> exec $SHELL

tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELL

Passaggio 3: installa Ruby

Prima di installare Ruby, determina quale versione di Ruby desideri installare. Installeremo Ruby 2.2.3. Usa il seguente comando per installare Ruby.

tp> rbenv install -v 2.2.3

Usa il seguente comando per impostare la versione corrente di Ruby come predefinita.

tp> rbenv global 2.2.3

Usa il seguente comando per verificare la versione di Ruby.

tp> ruby -v

Output

ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]

Ruby fornisce una parola chiave gemper l'installazione delle dipendenze supportate; li chiamiamogems. Se non vuoi installare la documentazione per Ruby-gems, usa il seguente comando.

tp> echo "gem: --no-document" > ~/.gemrc

Successivamente, è meglio installare la gemma Bundler, perché aiuta a gestire le dipendenze dell'applicazione. Usa il seguente comando per installare il bundler gem.

tp> gem install bundler

Passaggio 4: installazione di Rails

Usa il seguente comando per installare Rails versione 4.2.4.

tp> install rails -v 4.2.4

Usa il seguente comando per rendere disponibile l'eseguibile di Rails.

tp> rbenv rehash

Utilizzare il seguente comando per verificare la versione dei binari.

tp> rails -v

Output

tp> Rails 4.2.4

Il framework Ruby on Rails richiede JavaScript Runtime Environment (Node.js) per gestire le funzionalità di Rails. Successivamente, vedremo come possiamo usare Node.js per gestire Asset Pipeline, che è una funzionalità di Rails.

Passaggio 5: installa JavaScript Runtime

Installiamo Node.js dal repository Yum. Prenderemo Node.js dal repository yum di EPEL. Utilizzare il seguente comando per aggiungere il pacchetto EPEL al repository yum.

tp> sudo yum -y install epel-release

Utilizzare il seguente comando per installare il pacchetto Node.js.

tp> sudo yum install nodejs

Congratulazioni! Ora sei su Rails su Linux.

Passaggio 6: installazione del database

Per impostazione predefinita, Rails usa sqlite3, ma potresti voler installare MySQL, PostgreSQL o altri RDBMS. Questo è facoltativo; se hai il database installato, puoi saltare questo passaggio e non è obbligatorio che tu abbia un database installato per avviare il server rails. Per questo tutorial, utilizziamo il database PostgreSQL. Quindi usa i seguenti comandi per installare PostgreSQL.

tp> sudo yum install postgresql-server postgresql-contrib

Accetta la richiesta, rispondendo con a y. Utilizza il seguente comando per creare un cluster di database PostgreSQl.

tp> sudo postgresql-setup initdb

Usa il seguente comando per avviare e abilitare PostgreSQL.

tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresql

Mantenere i binari aggiornati

Supponendo che tu abbia installato Rails usando RubyGems, mantenerlo aggiornato è relativamente facile. Possiamo usare lo stesso comando sia sulla piattaforma Windows che su quella Linux. Usa il seguente comando:

tp> gem update rails

Output

Lo screenshot seguente mostra un prompt dei comandi di Windows. Anche il terminale Linux fornisce lo stesso output.

Questo aggiornerà automaticamente la tua installazione di Rails. La prossima volta che riavvierai la tua applicazione, verrà utilizzata l'ultima versione di Rails. Durante l'utilizzo di questo comando, assicurati di essere connesso a Internet.

Verifica dell'installazione

Puoi verificare se tutto è impostato in base alle tue esigenze oppure no. Usa il seguente comando per creare un progetto demo.

tp> rails new demo

Output

Genererà un progetto ferroviario dimostrativo; ne parleremo più tardi. Attualmente dobbiamo verificare se l'ambiente è impostato o meno. Quindi, usa il seguente comando per eseguire il server web WEBrick sulla tua macchina.

tp> cd demo
tp> rails server

Genererà un codice automatico per avviare il server

Ora apri il browser e digita quanto segue:

http://localhost:3000

Dovrebbe visualizzare un messaggio, qualcosa come "Benvenuto a bordo" o "Congratulazioni".

Un framework è un programma, un insieme di programmi e / o una libreria di codici che scrive la maggior parte dell'applicazione per te. Quando usi un framework, il tuo lavoro è scrivere le parti dell'applicazione che le fanno fare le cose specifiche che desideri.

Quando decidi di scrivere un'applicazione Rails, lasciando da parte la configurazione e le altre faccende domestiche, devi svolgere tre compiti principali:

Describe and model your application's domain- Il dominio è l'universo della tua applicazione. Il dominio può essere un negozio di musica, un'università, un servizio di appuntamenti, una rubrica o un inventario di hardware. Quindi qui devi capire cosa c'è dentro, quali entità esistono in questo universo e come gli elementi in esso si relazionano tra loro. Ciò equivale a modellare una struttura di database per mantenere le entità e la loro relazione.
Specify what can happen in this domain- Il modello di dominio è statico; devi renderlo dinamico. Gli indirizzi possono essere aggiunti a una rubrica. Gli spartiti musicali possono essere acquistati nei negozi di musica. Gli utenti possono accedere a un servizio di incontri. Gli studenti possono iscriversi alle lezioni presso un'università. Devi identificare tutti i possibili scenari o azioni a cui possono partecipare gli elementi del tuo dominio.
Choose and design the publicly available views of the domain- A questo punto, puoi iniziare a pensare in termini di browser web. Dopo aver deciso che il tuo dominio ha studenti e che possono registrarsi per i corsi, puoi visualizzare una pagina di benvenuto, una pagina di registrazione e una pagina di conferma, ecc. Ciascuna di queste pagine, o visualizzazioni, mostra all'utente come stanno le cose stare a un certo punto.

Sulla base delle tre attività precedenti, Ruby on Rails si occupa di un framework Model / View / Controller (MVC).

Ruby on Rails MVC Framework

Il Model Visualizzare CIl principio ontroller divide il lavoro di un'applicazione in tre sottosistemi separati ma strettamente cooperativi.

Modello (ActiveRecord)

Mantiene la relazione tra gli oggetti e il database e gestisce la convalida, l'associazione, le transazioni e altro.

Questo sottosistema è implementato nella libreria ActiveRecord, che fornisce un'interfaccia e un collegamento tra le tabelle in un database relazionale e il codice del programma Ruby che manipola i record del database. I nomi dei metodi Ruby vengono generati automaticamente dai nomi dei campi delle tabelle del database.

Visualizza (ActionView)

È una presentazione dei dati in un formato particolare, innescata dalla decisione di un responsabile del trattamento di presentare i dati. Sono sistemi di modelli basati su script come JSP, ASP, PHP e molto facili da integrare con la tecnologia AJAX.

Questo sottosistema è implementato nella libreria ActionView, che è un sistema basato su Embedded Ruby (ERb) per la definizione dei modelli di presentazione per la presentazione dei dati. Ogni connessione Web a un'applicazione Rails risulta nella visualizzazione di una vista.

Controller (ActionController)

La struttura all'interno dell'applicazione che dirige il traffico, da un lato, interrogando i modelli per dati specifici e, dall'altro, organizzando quei dati (ricerca, ordinamento, messaggistica) in una forma che si adatti alle esigenze di una data vista.

Questo sottosistema è implementato in ActionController, che è un broker di dati che si trova tra ActiveRecord (l'interfaccia del database) e ActionView (il motore di presentazione).

Rappresentazione pittorica di MVC Framework

Di seguito è riportata una rappresentazione pittorica di Ruby on Rails Framework:

Rappresentazione di directory di MVC Framework

Supponendo un'installazione standard e predefinita su Linux, puoi trovarli in questo modo:

tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> ls

Vedrai sottodirectory incluse (ma non limitate a) le seguenti:

actionpack-x.y.z
activerecord-x.y.z
rails-x.y.z

Su un'installazione di Windows, puoi trovarli in questo modo:

tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dir

Vedrai sottodirectory incluse (ma non limitate a) le seguenti:

ActionView e ActionController sono raggruppati in ActionPack.

ActiveRecord fornisce una gamma di tecniche di programmazione e scorciatoie per manipolare i dati da un database SQL. ActionController e ActionView forniscono funzionalità per la manipolazione e la visualizzazione di tali dati. Rails lega tutto insieme.

Quando usi lo script helper di Rails per creare la tua applicazione, viene creata l'intera struttura di directory per l'applicazione. Rails sa dove trovare le cose di cui ha bisogno all'interno di questa struttura, quindi non devi fornire alcun input.

Ecco una vista di primo livello di un albero di directory creato dallo script di supporto al momento della creazione dell'applicazione. Ad eccezione di piccoli cambiamenti tra i rilasci, ogni progetto Rails avrà la stessa struttura, con le stesse convenzioni di denominazione. Questa coerenza ti dà un enorme vantaggio; puoi spostarti rapidamente tra i progetti Rails senza riapprendere l'organizzazione del progetto.

Per comprendere questa struttura di directory, usiamo il demoapplicazione creata nel capitolo Installazione. Può essere creato utilizzando un semplice comando di supportorails demo.

Ora vai nella directory principale dell'applicazione demo come segue:

tp> cd demo
demo> dir

Troverai una struttura di directory in Windows come segue:

Ora spieghiamo lo scopo di ciascuna directory

app- Organizza i componenti dell'applicazione. Ha sottodirectory che contengono la vista (visualizzazioni e helper), controller (controller) e logica di business back-end (modelli).
app/controllers- La sottodirectory controllers è dove Rails cerca per trovare le classi controller. Un controller gestisce una richiesta web da parte dell'utente.
app/helpers- La sottodirectory helper contiene tutte le classi helper usate per assistere le classi model, view e controller. Ciò aiuta a mantenere il codice del modello, della vista e del controller piccolo, mirato e ordinato.
app/models- La sottodirectory models contiene le classi che modellano e racchiudono i dati memorizzati nel database della nostra applicazione. Nella maggior parte dei framework, questa parte dell'applicazione può diventare piuttosto disordinata, noiosa, dettagliata e soggetta a errori. Rails lo rende semplicissimo!
app/view - La sottodirectory delle visualizzazioni contiene i modelli di visualizzazione da compilare con i dati dalla nostra applicazione, convertire in HTML e tornare al browser dell'utente.
app/view/layouts- Contiene i file modello per i layout da utilizzare con le viste. Questo modella il metodo comune di intestazione / piè di pagina per il wrapping delle viste. Nelle visualizzazioni, definire un layout utilizzando <tt> layout: default </tt> e creare un file denominato default.html.erb. All'interno di default.html.erb, chiama <% yield%> per eseguire il rendering della vista utilizzando questo layout.
components - Questa directory contiene componenti, minuscole applicazioni autonome che raggruppano modello, visualizzazione e controller.
config- Questa directory contiene la piccola quantità di codice di configurazione di cui la tua applicazione avrà bisogno, inclusa la configurazione del tuo database (in database.yml), la struttura dell'ambiente Rails (environment.rb) e l'instradamento delle richieste web in arrivo (route.rb). Puoi anche personalizzare il comportamento dei tre ambienti Rails per test, sviluppo e distribuzione con i file trovati nella directory degli ambienti.
db- Di solito, la tua applicazione Rails avrà oggetti modello che accedono alle tabelle del database relazionale. È possibile gestire il database relazionale con gli script creati e inseriti in questa directory.
doc- Ruby ha un framework, chiamato RubyDoc, che può generare automaticamente la documentazione per il codice che crei. Puoi assistere RubyDoc con i commenti nel tuo codice. Questa directory contiene tutti i Rails generati da RubyDoc e la documentazione dell'applicazione.
lib - Metterai le librerie qui, a meno che non appartengano esplicitamente ad altro (come le librerie dei fornitori).
log- I log degli errori vanno qui. Rails crea script che ti aiutano a gestire vari log degli errori. Troverai log separati per il server (server.log) e ogni ambiente Rails (development.log, test.log e production.log).
public - Come la directory pubblica di un server web, questa directory contiene file web che non cambiano, come file JavaScript (public / javascripts), grafica (public / images), fogli di stile (public / stylesheets) e file HTML (public ).
script- Questa directory contiene gli script per avviare e gestire i vari strumenti che userete con Rails. Ad esempio, ci sono script per generare codice (generare) e avviare il server web (server).
test- I test che scrivi e quelli che Rails crea per te, vanno tutti qui. Vedrai una sottodirectory per mock (mock), unit test (unità), dispositivi (dispositivi) e test funzionali (funzionali).
tmp - Rails usa questa directory per conservare i file temporanei per l'elaborazione intermedia.
vendor - Le librerie fornite da fornitori di terze parti (come le librerie di sicurezza o le utilità di database oltre alla distribuzione di base di Rails) vanno qui.

Oltre a queste directory, ci saranno due file disponibili nella directory demo.

README - Questo file contiene i dettagli di base sull'applicazione Rail e la descrizione della struttura delle directory spiegata sopra.
Rakefile- Questo file è simile a Unix Makefile, che aiuta con la creazione, il packaging e il test del codice Rails. Questo sarà usato dall'utility rake fornita insieme all'installazione di Ruby.

In questo capitolo creeremo un sistema bibliotecario online semplice ma operativo per conservare e gestire i libri.

Questa applicazione ha un'architettura di base e sarà costruita utilizzando due modelli ActiveRecord per descrivere i tipi di dati archiviati:

Libri, che descrive un elenco effettivo.
Oggetto, utilizzato per raggruppare i libri.

Flusso di lavoro per la creazione di applicazioni Rails

Un flusso di lavoro consigliato per la creazione dell'applicazione Rails è il seguente:

Usa il comando rails per creare lo scheletro di base dell'applicazione.
Crea un database sul server PostgreSQL per conservare i tuoi dati.
Configura l'applicazione per sapere dove si trova il tuo database e le relative credenziali di accesso.
Crea record attivi di Rails (modelli), perché sono gli oggetti di business con cui lavorerai nei tuoi controller.
Genera migrazioni che semplificano la creazione e la manutenzione di tabelle e colonne di database.
Scrivi il codice del controller per dare vita alla tua applicazione.
Crea viste per presentare i tuoi dati tramite l'interfaccia utente.

Quindi, iniziamo con la creazione della nostra applicazione libreria.

Creazione di un'applicazione Web Rails vuota

Rails è sia un framework di applicazioni web runtime che un insieme di script di supporto che automatizzano molte delle cose che fai quando sviluppi un'applicazione web. In questo passaggio, utilizzeremo uno di questi script di supporto per creare l'intera struttura della directory e il set iniziale di file per avviare la nostra applicazione Library System.

Vai nella directory di installazione di ruby per creare la tua applicazione.
Eseguire il comando seguente per creare uno scheletro per l'applicazione della libreria. Creerà la struttura della directory nella directory corrente.

tp> rails new library

Questo creerà una sottodirectory per l'applicazione della libreria contenente un albero di directory completo di cartelle e file per un'applicazione Rails vuota. Verificare una struttura di directory completa dell'applicazione. Controlla la struttura delle directory di Rails per maggiori dettagli.

La maggior parte del nostro lavoro di sviluppo consisterà nella creazione e nella modifica di file in library/appsottodirectory. Ecco una rapida carrellata di come usarli:

La sottodirectory controllers è dove Rails cerca le classi dei controller. Un controller gestisce una richiesta web da parte dell'utente.
La vista sottodirectory contiene i modelli di visualizzazione di compilare con i dati di nostra applicazione, convertito in HTML, e ritorno al browser dell'utente.
La sottodirectory models contiene le classi che modellano e racchiudono i dati memorizzati nel database della nostra applicazione. Nella maggior parte dei framework, questa parte dell'applicazione può diventare piuttosto disordinata, noiosa, dettagliata e soggetta a errori. Rails lo rende semplicissimo.
La sottodirectory helper contiene tutte le classi helper usate per assistere le classi model, view e controller. Ciò aiuta a mantenere il codice del modello, della vista e del controller piccolo, mirato e ordinato.

Avvio del server Web

L'applicazione web Rails può essere eseguita praticamente su qualsiasi server web, ma il modo più conveniente per sviluppare un'applicazione web Rails è usare il web server WEBrick integrato. Avviamo questo server web e poi navighiamo nella nostra applicazione libreria vuota -

Questo server verrà avviato dalla directory dell'applicazione come segue. Funziona sulla porta numero 3000.

tp> cd ruby\library 
tp\ruby\library\> Rails server

Genera il codice automatico per avviare il server come mostrato di seguito -

Questo avvierà il tuo server web WEBrick.

Ora apri il browser e vai a http://127.0.0.1:3000. Se tutto è andato a buon fine, dovresti vedere un messaggio di saluto da WEBrick, altrimenti c'è qualcosa di sbagliato nella tua impostazione. Se tutto va bene, genererà l'output come segue.

Cosa c'è dopo?

Il capitolo successivo spiega come creare database per la propria applicazione e qual è la configurazione richiesta per accedere a questi database creati.

Inoltre, vedremo cos'è Rails Migration e come viene utilizzato per mantenere le tabelle del database.

Prima di iniziare con questo capitolo, assicurarsi che il server del database sia attivo e in esecuzione. Ruby on Rails consiglia di creare tre database: un database ciascuno per l'ambiente di sviluppo, test e produzione. Secondo la convenzione, i loro nomi dovrebbero essere:

library_development
library_production
library_test

È necessario inizializzarli tutti e tre e creare un utente e una password con privilegi di lettura e scrittura completi. Stiamo usando ilroot ID utente per la nostra applicazione.

Configurazione del database per MySQL

In MySQL, stiamo usando il rootID utente per la nostra applicazione. La sessione della console MySQL in cui si esegue questa operazione assomiglia a:

mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Puoi fare la stessa cosa per altri due database library_production e library_test.

Configurazione di database.yml

A questo punto, devi comunicare a Rails il nome utente e la password per i database. Puoi farlo nel filedatabase.yml, disponibile in library\configsottodirectory dell'applicazione Rails creata. Questo file ha sezioni di configurazione live per i database MySQL. In ciascuna delle sezioni che utilizzi, devi modificare le righe del nome utente e della password per riflettere le autorizzazioni sui database che hai creato.

Quando finisci, dovrebbe assomigliare a:

development:
   adapter: mysql
   database: library_development
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: library_test
   username: root
   password: [password]
   host: localhost
   
production:
   adapter: mysql
   database: library_production
   username: root
   password: [password]
   host: localhost

Configurazione del database per PostgreSQL

Per impostazione predefinita, PostgreSQL non fornisce alcun utente. Dobbiamo creare nuovi utenti. Utilizzare il seguente comando per creare un utente con il nomerubyuser.

tp> sudo -u postgres createuser rubyuser -s

Se desideri creare una password per il nuovo utente, utilizza il seguente comando.

tp> sudo -u postgres psql

postgres=# \password rubyuser

Usa il seguente comando per creare un database library_development.

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

Usa il seguente comando per creare un database library_production.

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

Usa il seguente comando per creare un database library_test.

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

stampa Ctrl+D per terminare PosgreSQL.

Configurazione di database.yml

A questo punto, devi far conoscere a Rails il nome utente e la password per i database. Puoi farlo nel filedatabase.yml, disponibile in library\configsottodirectory dell'applicazione Rails creata. Questo file ha sezioni di configurazione live per i database PostgreSQL. In ciascuna delle sezioni, è necessario modificare le righe del nome utente e della password per riflettere le autorizzazioni sui database che hai creato.

Al termine, dovrebbe apparire come segue:

default: &default
   adapter: postgresql
   encoding: unicode
  
development:
   adapter: postgresql
   encoding: unicode
   database: library_development
   username: rubyuser
   password: <Password for rubyuser>

test:
   adapter: postgresql
   encoding: unicode
   database: library_test
   username: rubyuser
   password: <Password for rubyuser>
 
production:
   adapter: postgresql
   encoding: unicode
   database: library_production
   username: rubyuser
   password: <Password for rubyuser>

Cosa c'è dopo?

I prossimi due capitoli spiegano come modellare le tabelle del database e come gestirle utilizzando Rails Migrations.

Rails Active Record è il layer Object / Relational Mapping (ORM) fornito con Rails. Segue da vicino il modello ORM standard, che è il seguente:

tabelle mappate alle classi,
righe mappate su oggetti e
colonne mappate agli attributi dell'oggetto.

Rails Active Records fornisce un'interfaccia e un collegamento tra le tabelle in un database relazionale e il codice del programma Ruby che manipola i record del database. I nomi dei metodi Ruby vengono generati automaticamente dai nomi dei campi delle tabelle del database.

Ogni oggetto Active Record ha CRUD (Create, Read, Update e Delete) metodi per l'accesso al database. Questa strategia consente progetti semplici e mappature dirette tra le tabelle del database e gli oggetti dell'applicazione.

Traduzione di un modello di dominio in SQL

Tradurre un modello di dominio in SQL è generalmente semplice, a patto di ricordare che è necessario scrivere SQL Rails-friendly. In termini pratici, devi seguire alcune regole:

Ogni entità (come il libro) ottiene una tabella nel database che prende il nome da essa, ma al plurale (libri).
Ciascuna di queste tabelle di corrispondenza delle entità ha un campo chiamato id , che contiene un numero intero univoco per ogni record inserito nella tabella.
Data l'entità x e l'entità y, se l'entità y appartiene all'entità x, la tabella y ha un campo chiamato x_id.
La maggior parte dei campi in qualsiasi tabella memorizza i valori per le proprietà semplici di quell'entità (qualsiasi cosa sia un numero o una stringa).

Creazione di file di record attivi (modelli)

Per creare i file Active Record per le nostre entità per l'applicazione della libreria, introdotti nel capitolo precedente, emettere il seguente comando dal livello superiore della directory dell'applicazione.

library\> ruby script/generate model Book
library\> ruby script/generate model Subject

Sopra rails generate model book comandi genera il codice automatico come di seguito -

Stai dicendo al generatore di creare modelli chiamati Libro e Soggetto per memorizzare istanze di libri e soggetti. Nota che stai usando le maiuscole per Libro e Oggetto e stai usando la forma singolare. Questo è un paradigma di Rails che dovresti seguire ogni volta che crei un modello.

Quando si utilizza lo strumento di generazione, Rails crea il file del modello effettivo che contiene tutti i metodi univoci per il modello e le regole di business definite, un file di unit test per eseguire lo sviluppo basato sui test, un file di dati di esempio (chiamato fixtures) da utilizzare con gli unit test e una migrazione di Rails che semplifica la creazione di tabelle e colonne di database.

Oltre a creare molti altri file e directory, questo creerà file denominati book.rb e subject.rb contenente una definizione di scheletro in app/models directory.

Contenuto disponibile in book.rb -

class Book < ActiveRecord::Base
end

Contenuto disponibile in subject.rb -

class Subject < ActiveRecord::Base
end

Creazione di associazioni tra modelli

Quando si dispone di più di un modello nella propria applicazione binari, è necessario creare una connessione tra questi modelli. Puoi farlo tramite associazioni. Active Record supporta tre tipi di associazioni:

one-to-one- Una relazione uno a uno esiste quando un elemento ha esattamente uno di un altro elemento. Ad esempio, una persona ha esattamente un compleanno o un cane ha esattamente un proprietario.
one-to-many- Esiste una relazione uno-a-molti quando un singolo oggetto può essere membro di molti altri oggetti. Ad esempio, un soggetto può avere molti libri.
many-to-many - Una relazione molti-a-molti esiste quando il primo oggetto è correlato a uno o più di un secondo oggetto e il secondo oggetto è correlato a uno o più del primo oggetto.

Indichi queste associazioni aggiungendo dichiarazioni ai tuoi modelli: has_one, has_many, appartiene_to e has_and_belongs_to_many.

Ora, devi dire a Rails quali relazioni vuoi stabilire all'interno del sistema di dati della libreria. Per farlo, modifica book.rb e subject.rb in questo modo:

class Book < ActiveRecord::Base
   belongs_to :subject
end

Abbiamo utilizzato un soggetto singolare nell'esempio precedente, perché un libro può appartenere a un singolo soggetto.

class Subject < ActiveRecord::Base
   has_many :books
end

Abbiamo usato libri plurali qui, perché un soggetto può avere più libri.

Implementazione di convalide sui modelli

L'implementazione delle validazioni viene eseguita in un modello Rails. I dati che stai inserendo nel database sono definiti nel modello Rails effettivo, quindi ha senso definire solo quali dati validi comportano nella stessa posizione.

Le convalide sono:

Il valore del campo del titolo non deve essere NULL.
Il valore del campo del prezzo deve essere numerico.

Aperto book.rb nel app\model subdiractory e inserire le seguenti convalide:

class Book < ActiveRecord::Base
   belongs_to :subject
   validates_presence_of :title
   validates_numericality_of :price, :message=>"Error Message"
end

validates_presence_of - protegge i campi "NOT NULL" dall'input dell'utente mancante.
validates_numericality_of - impedisce all'utente di inserire dati non numerici.

Oltre alle convalide di cui sopra, ci sono altre convalide comuni. Controlla la Guida rapida di Rails .

Cosa c'è dopo?

Nel prossimo capitolo impareremo Rails Migration, che ti permette di usare Ruby per definire le modifiche allo schema del tuo database, rendendo possibile l'uso di un sistema di controllo delle versioni per mantenere le cose sincronizzate con il codice reale.

Rails Migration ti permette di usare Ruby per definire le modifiche allo schema del tuo database, rendendo possibile l'uso di un sistema di controllo delle versioni per mantenere le cose sincronizzate con il codice reale.

Questo ha molti usi, tra cui:

Teams of developers - Se una persona apporta una modifica allo schema, gli altri sviluppatori devono solo aggiornare ed eseguire "rake migrate".
Production servers - Esegui "rake migrate" quando distribuisci una nuova versione per aggiornare anche il database.
Multiple machines - Se sviluppi sia su un desktop che su un laptop, o in più di una posizione, le migrazioni possono aiutarti a mantenerli tutti sincronizzati.

Cosa può fare Rails Migration?

create_table (nome, opzioni)
drop_table(name)
rename_table (old_name, new_name)
add_column (nome_tabella, nome_colonna, tipo, opzioni)
rename_column (table_name, column_name, new_column_name)
change_column (nome_tabella, nome_colonna, tipo, opzioni)
remove_column (nome_tabella, nome_colonna)
add_index (nome_tabella, nome_colonna, tipo_indice)
remove_index (nome_tabella, nome_colonna)

Migrations support all the basic data types - Di seguito è riportato l'elenco dei tipi di dati supportati dalla migrazione:

string - per piccoli tipi di dati come un titolo.
text - per dati testuali più lunghi, come la descrizione.
integer - per numeri interi.
float - per i decimali.
datetime and timestamp - memorizzare la data e l'ora in una colonna.
date and time - memorizzare solo la data o solo l'ora.
binary - per memorizzare dati come immagini, audio o filmati.
Boolean - per memorizzare valori veri o falsi.

Valid column options are - Di seguito è riportato l'elenco delle opzioni di colonna valide.

limit (: limit => "50")
default (: default => "blah")
null(: null => false implica NOT NULL )

NOTE - Le attività svolte da Rails Migration possono essere svolte utilizzando qualsiasi GUI front-end o direttamente sul prompt SQL, ma Rails Migration rende tutte queste attività molto semplici.

Vedi l' API Rails per i dettagli su questi.

Crea le migrazioni

Ecco la sintassi generica per creare una migrazione:

application_dir> rails generate migration table_name

Questo creerà il file db / migrate / 001_table_name.rb. Un file di migrazione contiene la sintassi di base di Ruby che descrive la struttura dei dati di una tabella di database.

NOTE - Prima di eseguire il generatore di migrazioni, si consiglia di pulire le migrazioni esistenti generate dai generatori di modelli.

Creeremo due migrazioni corrispondenti alle nostre tre tabelle: books and subjects.

La migrazione dei libri dovrebbe essere la seguente:

tp> cd library
library> rails generate migration books

Il comando sopra genera il codice seguente.

la migrazione dei soggetti dovrebbe essere la seguente:

tp> cd library
library> rails generate migration subjects

Il comando sopra genera il codice seguente.

Nota che stai usando lettere minuscole per il libro e l'oggetto e il plurale durante la creazione delle migrazioni. Questo è un paradigma di Rails che dovresti seguire ogni volta che crei una migrazione.

Modifica il codice

Vai alla sottodirectory db / migrate della tua applicazione e modifica ogni file uno per uno usando un qualsiasi semplice editor di testo.

Modificare 001_books.rb come segue:

La colonna ID verrà creata automaticamente, quindi non farlo anche qui.

class Books < ActiveRecord::Migration
   
   def self.up
      create_table :books do |t|
         t.column :title, :string, :limit => 32, :null => false
         t.column :price, :float
         t.column :subject_id, :integer
         t.column :description, :text
         t.column :created_at, :timestamp
      end
   end

   def self.down
      drop_table :books
   end
end

Il metodo self.up viene utilizzato durante la migrazione a una nuova versione, self.downviene utilizzato per ripristinare eventuali modifiche, se necessario. In questo momento, lo script precedente verrà utilizzato per crearebooks tavolo.

Modificare 002_subjects.rb come segue:

class Subjects < ActiveRecord::Migration
   def self.up
      
      create_table :subjects do |t|
         t.column :name, :string
      end
	
      Subject.create :name => "Physics"
      Subject.create :name => "Mathematics"
      Subject.create :name => "Chemistry"
      Subject.create :name => "Psychology"
      Subject.create :name => "Geography"
   end

   def self.down
      drop_table :subjects
   end
end

Lo script precedente verrà utilizzato per creare subjects tabella e creerà cinque record nella tabella dei soggetti.

Esegui la migrazione

Ora che hai creato tutti i file di migrazione richiesti. È il momento di eseguirli sul database. Per fare ciò, vai a un prompt dei comandi e vai alla directory della libreria in cui si trova l'applicazione, quindi digitarake migrate come segue -

library> rake db:migrate

Questo creerà una tabella "schema_info" se non esiste, che tiene traccia della versione corrente del database: ogni nuova migrazione sarà una nuova versione e ogni nuova migrazione verrà eseguita finché il database non sarà alla versione corrente.

Rakeè un programma di costruzione di Ruby simile a Unix make programma che Rails sfrutta, per semplificare l'esecuzione di compiti complessi come l'aggiornamento la struttura di una banca dati, ecc

Esecuzione di migrazioni per database di produzione e test

Se desideri specificare quale ambiente Rails utilizzare per la migrazione, utilizza la variabile di shell RAILS_ENV.

Ad esempio:

library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrate

NOTE- In Windows, usa "set RAILS_ENV = production" invece del comando export .

Cosa c'è dopo?

Ora abbiamo a disposizione il nostro database e le tabelle richieste. Nei due capitoli successivi, esploreremo due componenti importanti chiamati Controller (ActionController) e View (ActionView).

Creazione di controller (controller di azione).
Creazione di viste (visualizzazione azione).

Il controller Rails è il centro logico della tua applicazione. Coordina l'interazione tra l'utente, le viste e il modello. Il responsabile del trattamento è anche sede di una serie di importanti servizi ausiliari.

È responsabile dell'instradamento delle richieste esterne alle azioni interne. Gestisce estremamente bene gli URL a misura di utente.
Gestisce il caching, che può dare alle applicazioni miglioramenti delle prestazioni di ordini di grandezza.
Gestisce i moduli di supporto, che estendono le capacità dei modelli di visualizzazione senza aumentare il loro codice.
Gestisce le sessioni, dando agli utenti l'impressione di una continua interazione con le nostre applicazioni.

Il processo per creare un controller è molto semplice ed è simile al processo che abbiamo già utilizzato per creare un modello. Creeremo solo un controller qui -

library\> rails generate controller Book

Nota che stai usando le maiuscole Book e stai usando la forma singolare. Questo è un paradigma di Rails che dovresti seguire ogni volta che crei un controller.

Questo comando esegue diverse attività, di cui le seguenti sono rilevanti qui:

Crea un file chiamato app/controllers/book_controller.rb

Se guardi book_controller.rb, lo troverai come segue:

class BookController < ApplicationController
end

Le classi controller ereditano da ApplicationController, che è l'altro file nella cartella controller:application.rb.

L' ApplicationController contiene codice che può essere eseguito in tutti i controller e eredita dalla classe Rails ActionController :: Base .

Non devi ancora preoccuparti di ApplicationController , quindi definiamo solo alcuni stub di metodo inbook_controller.rb. In base alle proprie esigenze, è possibile definire un numero qualsiasi di funzioni in questo file.

Modifica il file in modo che abbia l'aspetto seguente e salva le modifiche. Nota che dipende da te quale nome vuoi dare a questi metodi, ma è meglio dare nomi pertinenti.

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

Ora implementiamo tutti i metodi uno per uno.

Implementazione del metodo elenco

Il metodo elenco fornisce un elenco di tutti i libri nel database. Questa funzionalità verrà ottenuta dalle seguenti righe di codice. Modifica le seguenti righe nel file book_controller.rb.

def list
   @books = Book.all
end

La riga @books = Book.all nel metodo list dice a Rails di cercare nella tabella dei libri e memorizzare ogni riga che trova nell'oggetto istanza @books.

Implementazione del metodo show

Il metodo mostra mostra solo ulteriori dettagli su un singolo libro. Questa funzionalità verrà ottenuta dalle seguenti righe di codice.

def show
   @book = Book.find(params[:id])
end

La riga @book = Book.find (params [: id]) del metodo show dice a Rails di trovare solo il libro che ha l'id definito in params [: id].

L'oggetto params è un contenitore che consente di passare valori tra le chiamate di metodo. Ad esempio, quando sei sulla pagina chiamata dal metodo list, puoi fare clic su un collegamento per un libro specifico e passa l'ID di quel libro tramite l'oggetto params in modo che show possa trovare il libro specifico.

Implementazione del nuovo metodo

Il nuovo metodo fa sapere a Rails che creerai un nuovo oggetto. Quindi aggiungi il seguente codice in questo metodo.

def new
   @book = Book.new
   @subjects = Subject.all
end

Il metodo sopra verrà chiamato quando mostrerai una pagina all'utente per ricevere l'input dell'utente. Qui la seconda riga prende tutti i soggetti dal database e li inserisce in un array chiamato @subjects.

Implementazione del metodo create

Dopo aver ricevuto l'input dell'utente utilizzando il modulo HTML, è il momento di creare un record nel database. Per ottenere ciò, modifica il metodo create nel book_controller.rb in modo che corrisponda a quanto segue:

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

La prima riga crea una nuova variabile di istanza chiamata @book che contiene un oggetto Book costruito dai dati, l'utente inviato. Ilbook_params viene utilizzato per raccogliere tutti i campi dall'oggetto :books. I dati sono stati passati dal nuovo metodo per creare utilizzando l'oggetto params.

La riga successiva è un'istruzione condizionale che reindirizza l'utente al file listmetodo se l'oggetto viene salvato correttamente nel database. Se non viene salvato, l'utente viene rimandato al nuovo metodo. Il metodo redirect_to è simile all'esecuzione di un meta refresh su una pagina web: ti inoltra automaticamente alla tua destinazione senza alcuna interazione da parte dell'utente.

Quindi @subjects = Subject.all è richiesto nel caso in cui non salvi i dati correttamente e diventi simile a quello della nuova opzione.

Implementazione del metodo di modifica

Il metodo di modifica sembra quasi identico al metodo show. Entrambi i metodi vengono utilizzati per recuperare un singolo oggetto in base al suo ID e visualizzarlo su una pagina. L'unica differenza è che il metodo di visualizzazione non è modificabile.

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

Questo metodo verrà chiamato per visualizzare i dati sullo schermo che verranno modificati dall'utente. La seconda riga cattura tutti i soggetti dal database e li inserisce in un array chiamato @subjects.

Implementazione del metodo di aggiornamento

Questo metodo verrà chiamato dopo il metodo di modifica, quando l'utente modifica un dato e desidera aggiornare le modifiche nel database. Il metodo di aggiornamento è simile al metodo di creazione e verrà utilizzato per aggiornare i libri esistenti nel database.

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

Il metodo update_attributes è simile al metodo save utilizzato da create ma invece di creare una nuova riga nel database, sovrascrive gli attributi della riga esistente.

Quindi @subjects = Subject.all è richiesta la riga nel caso in cui non salvi i dati correttamente, quindi diventa simile all'opzione di modifica.

Implementazione del metodo di eliminazione

Se desideri eliminare un record dal database, utilizzerai questo metodo. Implementa questo metodo come segue.

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

La prima riga trova il classificato in base al parametro passato tramite l'oggetto params e quindi lo elimina utilizzando il metodo destroy. La seconda riga reindirizza l'utente al metodo list utilizzando una chiamata redirect_to.

Metodi aggiuntivi per visualizzare i soggetti

Supponi di voler offrire ai tuoi utenti la possibilità di sfogliare tutti i libri in base a un determinato argomento. Quindi, puoi creare un metodo all'interno di book_controller.rb per visualizzare tutti gli argomenti. Supponiamo che il nome del metodo siashow_subjects -

def show_subjects
   @subject = Subject.find(params[:id])
end

Finalmente il tuo book_controller.rb il file avrà il seguente aspetto:

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

Ora salva il file del controller.

Cosa c'è dopo?

Hai creato quasi tutti i metodi, che funzioneranno sul backend. Successivamente definiremo percorsi (URL) per le azioni.

Il modulo di routing fornisce la riscrittura degli URL in Ruby nativo. È un modo per reindirizzare le richieste in arrivo ai controller e alle azioni. Sostituisce le regole mod_rewrite. Soprattutto, Rails 'Routing funziona con qualsiasi server web. I percorsi sono definiti in app / config / routes.rb.

Pensa a creare percorsi come disegnare una mappa per le tue richieste. La mappa dice loro dove andare in base a uno schema predefinito -

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

Esempio

Consideriamo che la nostra applicazione di gestione delle librerie contiene un controller chiamato BookController. Dobbiamo definire le rotte per quelle azioni che sono definite come metodi nella classe BookController.

Apri il file routes.rb nella directory library / config / e modificalo con il seguente contenuto.

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

Il file routes.rb definisce le azioni disponibili nelle applicazioni e il tipo di azione come get, post e patch.

Usa il seguente comando per elencare tutte le tue rotte definite, utili per rintracciare i problemi di instradamento nella tua applicazione o per darti una buona panoramica degli URL in un'applicazione con cui stai cercando di familiarizzare.

library> rake routes

Cosa c'è dopo?

Successivamente, creeremo il codice per generare schermate per visualizzare i dati e ricevere input dall'utente.

A Rails View è un programma ERb che condivide i dati con i controller tramite variabili reciprocamente accessibili.

Se guardi nella directory app / views dell'applicazione libreria, vedrai una sottodirectory per ciascuno dei controller, abbiamo creato: book. Ciascuna di queste sottodirectory è stata creata automaticamente quando il controller con lo stesso nome è stato creato con lo script di generazione.

Rails ti fa sapere che devi creare il file di visualizzazione per ogni nuovo metodo. Ogni metodo definito nel controller deve avere un fileerb file, con lo stesso nome del metodo, per visualizzare i dati che il metodo sta raccogliendo.

Quindi creiamo i file di visualizzazione per tutti i metodi che abbiamo definito in book_controller.rb. Durante l'esecuzione di queste viste, controlla simultaneamente che queste azioni siano applicabili o meno nel database.

Creazione del file di visualizzazione per il metodo elenco

Crea un file chiamato list.html.erbutilizzando il tuo editor di testo preferito e salvalo su app / visualizzazioni / libro. Dopo aver creato e salvato il file, aggiorna il browser web. Dovresti vedere una pagina vuota; se non lo fai, controlla l'ortografia del tuo file e assicurati che sia esattamente lo stesso del metodo del tuo controller.

Ora visualizza il contenuto effettivo. Mettiamo il seguente codice in list.html.erb.

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

Il codice da eseguire è controllare se l'array @books contiene oggetti. Il.blank?restituisce true se l'array è vuoto e false se contiene oggetti. Questo oggetto @books è stato creato nel controller all'interno del metodo list.

Il codice tra i tag <% =%> è un file link_tochiamata al metodo. Il primo parametro di link_to è il testo da visualizzare tra i tag <a>. Il secondo parametro è quale azione viene chiamata quando si fa clic sul collegamento. In questo caso, è il metodo dello spettacolo. Il parametro finale è l'id del libro che viene passato tramite l'oggetto params.

Ora, prova ad aggiornare il browser e dovresti ottenere la seguente schermata perché non abbiamo alcun libro nella nostra libreria.

Creazione di file di visualizzazione per un nuovo metodo

Fino ad ora, non abbiamo nessun libro nella nostra biblioteca. Dobbiamo creare pochi libri nel sistema. Quindi, progettiamo una vista corrispondente al filenew metodo definito in book_controller.rb.

Crea un file chiamato new.html.erb usando il tuo editor di testo preferito e salvalo su app / views / book. Aggiungi il codice seguente al file new.html.erb.

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

Qui form_tagIl metodo interpreta il codice Ruby in un normale tag HTML <form> utilizzando tutte le informazioni fornite. Questo tag, ad esempio, restituisce il seguente HTML:

<form action = "/book/create" method = "post">

Il prossimo metodo è text_fieldche restituisce un campo di testo <input>. I parametri per text_field sono object e field name. In questo caso l'oggetto è un libro e il nome è il titolo .

Metodo Rails chiamato collection_select, crea un menu di selezione HTML costruito da un array, come quello @books. Ci sono cinque parametri, che sono i seguenti:

:book - L'oggetto che stai manipolando. In questo caso, è un oggetto libro.
:subject_id - Il campo che viene compilato quando il libro viene salvato.
@books - L'array con cui stai lavorando.
:id- Il valore memorizzato nel database. In termini di HTML, questo è il parametro value del tag <option>.
:name- L'output che l'utente vede nel menu a discesa. Questo è il valore tra i tag <option>.

Il prossimo utilizzato è submit_tag, che restituisce un pulsante <input> che invia il modulo. Infine, c'è ilend metodo che si traduce semplicemente in </form>.

Vai al tuo browser e visita http://localhost:3000/book/new. Questo ti darà la seguente schermata.

Immettere alcuni dati in questo modulo e quindi fare clic sul pulsante Crea. Qui ho aggiunto i seguenti dettagli nei campi:

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

Quando fai clic sul file Create pulsante, chiamerà il create metodo, che non necessita di alcuna visualizzazione perché questo metodo utilizza entrambi list o newmetodi per visualizzare i risultati. Quindi, quando fai clic sul pulsante Crea, i dati dovrebbero essere inviati correttamente e reindirizzare alla pagina dell'elenco, in cui ora hai un singolo elemento elencato come segue:

Se fai clic sul collegamento, dovresti vedere un altro errore di modello mancante, poiché non hai ancora creato il file modello per il metodo di visualizzazione.

Creazione del file di visualizzazione per il metodo show

Questo metodo visualizzerà i dettagli completi su qualsiasi libro disponibile nella libreria. Crea un file show.html.erb in app / views / book e popolalo con il seguente codice:

<h1><%= @book.title %></h1>

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

<%= link_to 'Back', {:action => 'list'} %>

Questa è la prima volta che hai sfruttato appieno le associazioni, che ti consentono di estrarre facilmente i dati dagli oggetti correlati.

Il formato utilizzato è @variable.relatedObject.column. In questo caso, puoi estrarre il valore del nome del soggetto tramite la variabile @book utilizzando ilbelongs_toassociazioni. Se fai clic su un record elencato, ti verrà mostrata la schermata seguente.

Creazione del file di visualizzazione per il metodo di modifica

Crea un nuovo file chiamato edit.html.erb e salvalo in app / views / book. Popolarlo con il codice seguente:

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

<%= link_to 'Back', {:action => 'list' } %>

Questo codice è molto simile al new metodo tranne l'azione da aggiornare invece di creare e definire un id.

In questo scenario, abbiamo usato form_fortag per l'azione del modulo. Funzionerà meglio diform_tag. Perché perché creerà facilmente interazione con il Modello. Pertanto è meglio utilizzare il tag form_for ogni volta che è necessaria l'interazione tra il modello ei campi del modulo.

A questo punto, abbiamo bisogno di alcune modifiche nel file list method'svedi il file. Vai all'elemento <li> </li> e modificalo in modo che abbia il seguente aspetto:

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

Ora prova a sfogliare i libri utilizzando il http://localhost:3000/book/list. Ti darà l'elenco di tutti i libri insieme a Editopzione. Quando fai clic sull'opzione Modifica, avrai la schermata successiva come segue:

Ora modifichi queste informazioni e poi fai clic sul pulsante Salva modifiche . Ciò si tradurrà in una chiamata aupdatedisponibile nel file del controller e aggiornerà tutti gli attributi modificati. Si noti che il fileupdate metodo non ha bisogno di alcun file di visualizzazione perché utilizza entrambi show o edit metodi per mostrare i suoi risultati.

Creazione del file di visualizzazione per il metodo di eliminazione

Rimuovere le informazioni da un database utilizzando Ruby on Rails è quasi troppo facile. Non è necessario scrivere alcun codice di visualizzazione per il metodo di eliminazione perché questo metodo sta utilizzandolistmetodo per visualizzare il risultato. Quindi, modifichiamo di nuovo list.html.erb e aggiungiamo un link di eliminazione.

Vai all'elemento <li> </li> e modificalo in modo che abbia il seguente aspetto:

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

Il :confirmIl parametro presenta una finestra di conferma JavaScript che chiede se si desidera veramente eseguire l'azione. Se l'utente fa clic su OK, l'azione procede e l'elemento viene eliminato.

Ora prova a sfogliare i libri usando http://localhost:3000/book/list. Ti darà un elenco di tutti i libri insieme a Edit e Delete opzioni come segue:

Ora utilizzando l'opzione Elimina, puoi eliminare qualsiasi record elencato.

Creazione del file di visualizzazione per il metodo show_subjects

Crea un nuovo file, show_subjects.html.erb, nella directory app / views / book e aggiungi il seguente codice ad esso -

<h1><%= @subject.name -%></h1>

<ul>
   <% @subject.books.each do |c| %>
   <li><%= link_to c.title, :action => "show", :id => c.id -%></li>
   <% end %>
</ul>

Stai sfruttando le associazioni iterando attraverso i numerosi elenchi di libri di un singolo argomento.

Ora modifica la riga Oggetto: di show.html.erb in modo che l'elenco degli argomenti mostri un collegamento.

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

Questo produrrà un elenco di argomenti nella pagina dell'indice, in modo che gli utenti possano accedervi direttamente.

Modificare list.html.erb per aggiungere quanto segue all'inizio del file:

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

Ora prova a sfogliare i libri utilizzando http: // localhost: 3000 / book / list. Mostrerà tutti gli argomenti con i collegamenti in modo da poter sfogliare tutti i libri relativi a quell'argomento.

Cosa c'è dopo?

Spero che ora ti senta a tuo agio con tutte le operazioni di Rails.

Il prossimo capitolo spiega come usare Layoutsper mettere i tuoi dati in un modo migliore. Ti mostreremo come usare i CSS nelle tue applicazioni Rails.

Un layout definisce l'ambiente circostante una pagina HTML. È il luogo in cui definire un aspetto comune del tuo output finale. I file di layout risiedono in app / visualizzazioni / layout.

Il processo prevede la definizione di un modello di layout e quindi la comunicazione al controller che esiste e che lo utilizzi. Per prima cosa, creiamo il modello.

Aggiungi un nuovo file chiamato standard.html.erb ad app / views / layouts. Si comunica ai controller quale modello utilizzare con il nome del file, quindi si consiglia di seguire lo stesso schema di denominazione.

Aggiungi il codice seguente al nuovo file standard.html.erb e salva le modifiche -

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

Tutto ciò che hai appena aggiunto erano elementi HTML standard tranne due righe. Ilstylesheet_link_tagIl metodo helper genera un foglio di stile <link>. In questo caso, stiamo collegando il foglio di stile style.css. Ilyield comando fa sapere a Rails che dovrebbe mettere html.erb per il metodo chiamato qui.

Ora aperto book_controller.rb e aggiungi la riga seguente appena sotto la prima riga:

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

Indica al controller che vogliamo utilizzare un layout disponibile nel file standard.html.erb. Ora prova a sfogliare i libri che produrranno la seguente schermata.

Aggiunta di fogli di stile

Fino ad ora, non abbiamo creato alcun foglio di stile, quindi Rails sta usando il foglio di stile predefinito. Ora creiamo un nuovo file chiamato style.css e lo salviamo in / public / stylesheets. Aggiungi il codice seguente a questo file.

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

Ora aggiorna il tuo browser e vedi la differenza -

Cosa c'è dopo?

Il prossimo capitolo spiega come sviluppare applicazioni usando Rails Scaffolding per dare agli utenti l'accesso per aggiungere, eliminare e modificare i record in qualsiasi database.

Mentre stai sviluppando applicazioni Rails, specialmente quelle che ti forniscono principalmente una semplice interfaccia per i dati in un database, spesso può essere utile usare il metodo scaffold.

Le impalcature offrono più che brividi demo economici. Ecco alcuni vantaggi:

Puoi ottenere rapidamente il codice davanti ai tuoi utenti per il feedback.
Sei motivato da un successo più veloce.
Puoi imparare come funziona Rails guardando il codice generato.
Puoi utilizzare lo scaffolding come base per avviare rapidamente il tuo sviluppo.

Esempio di ponteggi

Per comprendere lo scaffolding, creiamo un database chiamatocookbook e un tavolo chiamato recipes.

Creazione di un'applicazione Web Rails vuota

Apri una finestra di comando e vai alla posizione in cui desideri crearla cookbookapplicazione web. Quindi, esegui il seguente comando per creare una struttura di directory completa.

tp> rails new cookbook

Configurazione del database

Ecco il modo per creare un database:

mysql> create database cookbook;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on cookbook.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Per istruire Rails su come trovare il database, modificare il file di configurazione cookbook \ config \ database.yml e cambiare il nome del database in cookbook. Lascia la password vuota. Al termine, dovrebbe apparire come segue:

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

Rails ti consente di eseguire in modalità sviluppo, modalità test o modalità produzione, utilizzando diversi database. Questa applicazione utilizza lo stesso database per ciascuno.

Il codice dello scaffold generato

Con l'azione scaffold, Rails genera dinamicamente tutto il codice di cui ha bisogno. Eseguendo scaffold come script, possiamo ottenere tutto il codice scritto su disco, dove possiamo esaminarlo e quindi iniziare ad adattarlo alle nostre esigenze.

Quindi ora, iniziamo ancora una volta a generare manualmente il codice Scaffold utilizzando lo script helper scaffold -

cookbook> rails generate scaffold recipe

Genera file automatici come mostrato di seguito -

Il controller

Diamo un'occhiata al codice dietro il controller. Questo codice è generato dascaffoldGeneratore. Se apri app / controllers / ricette_controller.rb, troverai qualcosa come segue:

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

Quando l'utente di un'applicazione Rails seleziona un'azione, ad esempio "Show" - il controller eseguirà qualsiasi codice nella sezione appropriata - "def show" - e quindi di default renderà un template con lo stesso nome - "show.html. erb ". Questo comportamento predefinito può essere sovrascritto.

Il controller utilizza metodi ActiveRecord come find, find_all, new, save, update_attributes e destroy per spostare i dati da e verso le tabelle del database. Nota che non devi scrivere alcuna istruzione SQL, rails se ne occuperà automaticamente.

Questa singola riga di codice darà vita alla tabella del database. Fornirà una semplice interfaccia ai tuoi dati e modi per:

Creazione di nuove voci
Modifica delle voci correnti
Visualizzazione delle voci correnti
Distruggere le voci correnti

Quando crei o modifichi una voce, scaffold farà tutto il lavoro duro come la generazione e la gestione del modulo per te e fornirà anche una generazione intelligente del modulo, supportando i seguenti tipi di input:

Stringhe di testo semplici
Aree di testo (o grandi blocchi di testo)
Selettori di data
Selettori di data e ora

Puoi usare Rails Migrations per creare e mantenere tabelle.

rake db:migrate RAILS_ENV=development

Ora vai alla directory del ricettario ed esegui il server Web utilizzando il seguente comando:

cookbook> rails server

Ora apri un browser e vai a http://127.0.0.1:3000/recipe/new. Questo ti fornirà una schermata per creare nuove voci nella tabella delle ricette. Di seguito è mostrato uno screenshot:

Una volta premuto il pulsante Create pulsante per creare una nuova ricetta, il tuo record viene aggiunto alla tabella delle ricette e mostra il seguente risultato:

Puoi vedere l'opzione per modificare, mostrare e distruggere i record. Quindi, gioca con queste opzioni.

Puoi anche elencare tutte le ricette disponibili nella tabella delle ricette utilizzando l'URL http://127.0.0.1:3000/recipe/list.

Migliorare il modello

Rails ti offre un sacco di gestione degli errori gratuitamente. Per capirlo, aggiungi alcune regole di convalida al modello di ricetta vuoto -

Modifica app / models / ricetta.rb come segue e poi prova la tua applicazione -

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

Queste voci daranno un controllo automatico.

validates_length_of - il campo non è vuoto e non è troppo lungo.
validates_uniqueness_of- i valori duplicati vengono intrappolati. Invece del messaggio di errore predefinito di Rails, abbiamo fornito un messaggio personalizzato qui.

Modo alternativo per creare impalcature

Crea un'applicazione come mostrato sopra e The Generated Scaffold Code come mostrato di seguito

rails g scaffold Recipe tittle:string instructions:text

Il codice sopra genera i file automatici con il database utilizzando sqlite3 con tittle e colonna di istruzioni come mostrato sotto un'immagine.

abbiamo bisogno di migrare il database utilizzando la sintassi seguente.

$ rake db:migrate RAILS_ENV=development

Infine, esegui l'applicazione utilizzando la seguente riga di comando:

rails server

Genererà il risultato come mostrato sopra le immagini di output.

Le visualizzazioni

Tutte le viste e tutti i metodi del controller corrispondenti vengono creati da scaffold e sono disponibili nella directory app / views / ricette.

In che modo le impalcature sono diverse?

Se hai seguito i capitoli precedenti, devi aver visto che abbiamo creato metodi per elencare, mostrare, eliminare e creare dati, ecc., Ma lo scaffolding fa quel lavoro automaticamente.

Ajax sta per Asincrono JavaScript e XML. Ajax non è una singola tecnologia; è una suite di diverse tecnologie. Ajax incorpora quanto segue:

XHTML per il markup delle pagine web
CSS per lo styling
Visualizzazione dinamica e interazione utilizzando il DOM
Manipolazione e scambio di dati tramite XML
Recupero dei dati utilizzando XMLHttpRequest
JavaScript come collante che unisce tutto questo

Ajax ti consente di recuperare i dati per una pagina web senza dover aggiornare i contenuti dell'intera pagina. Nell'architettura web di base, l'utente fa clic su un collegamento o invia un modulo. Il modulo viene inviato al server, che quindi restituisce una risposta. La risposta viene quindi visualizzata per l'utente su una nuova pagina.

Quando interagisci con una pagina Web basata su Ajax, viene caricato un motore Ajax in background. Il motore è scritto in JavaScript e la sua responsabilità è sia di comunicare con il server web sia di mostrare i risultati all'utente. Quando si inviano i dati utilizzando un modulo alimentato da Ajax, il server restituisce un frammento HTML che contiene la risposta del server e visualizza solo i dati nuovi o modificati invece di aggiornare l'intera pagina.

Per un dettaglio completo su AJAX puoi consultare il nostro Tutorial AJAX

Come Rails implementa Ajax

Rails ha un modello semplice e coerente per come implementa le operazioni Ajax. Una volta che il browser ha eseguito il rendering e visualizzato la pagina Web iniziale, diverse azioni dell'utente determinano la visualizzazione di una nuova pagina Web (come qualsiasi applicazione Web tradizionale) o l'attivazione di un'operazione Ajax -

Some trigger fires - Questo trigger potrebbe essere l'utente che fa clic su un pulsante o un collegamento, l'utente che apporta modifiche ai dati in un modulo o in un campo o solo un trigger periodico (basato su un timer).
The web client calls the server- Un metodo JavaScript, XMLHttpRequest , invia i dati associati al trigger a un gestore di azioni sul server. I dati potrebbero essere l'ID di una casella di controllo, il testo in un campo di immissione o un intero modulo.
The server does processing - Il gestore dell'azione lato server (azione del controller Rails) - fa qualcosa con i dati e restituisce un frammento HTML al client web.
The client receives the response - Il JavaScript lato client, che Rails crea automaticamente, riceve il frammento HTML e lo utilizza per aggiornare una parte specifica dell'HTML della pagina corrente, spesso il contenuto di un tag <div>.

Questi passaggi sono il modo più semplice per usare Ajax in un'applicazione Rails, ma con un po 'di lavoro in più, puoi fare in modo che il server restituisca qualsiasi tipo di dati in risposta a una richiesta Ajax e puoi creare JavaScript personalizzato nel browser per eseguire di più interazioni coinvolte.

Esempio AJAX

Questo esempio funziona in base a scaffold, il concetto Destroy funziona in base a ajax.

In questo esempio, forniremo, elencheremo, mostreremo e creeremo operazioni sulla tabella dei pony. Se non hai compreso la tecnologia dello scaffold, ti suggeriamo di leggere prima i capitoli precedenti e poi continuare con AJAX on Rails.

Creazione di un'applicazione

Cominciamo con la creazione di un'applicazione Sarà fatto come segue:

rails new ponies

Il comando precedente crea un'applicazione, ora dobbiamo chiamare la directory dell'app usando il comando cd. Entrerà in una directory dell'applicazione, quindi dobbiamo chiamare un comando scaffold. Sarà fatto come segue:

rails generate scaffold Pony name:string profession:string

Il comando sopra genera lo scaffold con il nome e la colonna della professione. Abbiamo bisogno di migrare il database come segue comando

rake db:migrate

Ora esegui l'applicazione Rails come segue comando

rails s

Ora apri il browser web e chiama un URL come http: // localhost: 3000 / ponies / new, L'output sarà il seguente

Creazione di un Ajax

Ora apri app / views / ponies / index.html.erb con editor di testo adeguati. Aggiorna la tua riga di distruzione con: remote => true,: class => 'delete_pony' Alla fine, sembra come segue.

Crea un file, destroy.js.erb, mettilo accanto agli altri tuoi file .erb (sotto app / views / ponies). Dovrebbe assomigliare a questo -

Ora inserisci il codice come mostrato di seguito in destroy.js.erb

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

Ora apri il file del controller che si trova in app / controllers / ponies_controller.rb e aggiungi il seguente codice nel metodo di distruzione come mostrato di seguito:

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

Alla fine la pagina del controller è come l'immagine mostrata.

Ora esegui un'applicazione, output chiamato da http: // localhost: 3000 / ponies / new, apparirà come nell'immagine seguente

Premere sul pulsante crea pony, genererà il risultato come segue

Ora fai clic sul pulsante Indietro, mostrerà tutte le informazioni create dal pony come mostrato nell'immagine

Fino ad ora, stiamo lavorando su scaffold, ora fai clic sul pulsante di distruzione, chiamerà un pop-up come mostrato nell'immagine sotto, il pop-up funziona in base a Ajax.

Se fai clic sul pulsante ok, cancellerà il record da pony. Qui ho fatto clic sul pulsante ok. L'output finale sarà il seguente:

Potresti avere un requisito in base al quale desideri che i visitatori del tuo sito caricino un file sul tuo server. Rails rende molto facile gestire questo requisito. Ora procederemo con un semplice e piccolo progetto Rails.

Come al solito, iniziamo con una nuova applicazione Rails chiamata testfile. Creiamo la struttura di base dell'applicazione utilizzando il semplice comando rails.

tp> rails new testfile

Prima di iniziare lo sviluppo dell'applicazione, dovremmo installare i file gem come mostrato di seguito -

gem install carrierwave
gem install bootstrap-sass

Apri il tuo gemfile e aggiungi le seguenti due gemme in basso come mostrato nell'immagine seguente:

Dopo aver aggiunto gemme nel file gem, dobbiamo eseguire il seguente comando sulla console:

bundle install

Creazione del modello

Dobbiamo creare un modello con due stringhe come nome e allegato come mostrato di seguito -

rails g model Resume name:string attachment:string

Dobbiamo creare la migrazione del database come mostrato di seguito -

rake db:migrate

Dobbiamo generare il controller come mostrato di seguito -

rails g controller Resumes index new create destroy

Grande! Ora abbiamo la struttura di base impostata. Ora dobbiamo creare un uploader. Un Uploader è arrivato da carrierwave gem e dice a carrierwave come gestire i file. In breve, conteneva tutte le funzionalità di elaborazione dei file. Esegui il comando per creare un uploader come mostrato di seguito

rails g uploader attachment

Ora apri il modello di curriculum e chiama l'uploader come mostrato di seguito. Il modello di ripresa è stato posizionato in app / models / resume.rb -

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

Prima di lavorare sul controller, dobbiamo modificare il nostro config / routes.db come mostrato di seguito -

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

Ci consente di modificare il controller come mostrato di seguito.

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

Aggiungiamo l'implementazione bootstrap nel file css file.css potrebbe essere in app / assets / stylesheets / resumes.css.scss

@import "bootstrap";

Ora apri app / views / layouts / application.html.erb e aggiungi i codici come mostrato di seguito -

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

Ora dobbiamo impostare le viste indice come mostrato di seguito:

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

Ora, modifichiamo new.html.erb e aggiungiamo il nostro codice del modulo.

<% if [email protected]? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

Ora avvia il server e visita http: // localhost: 3000. Produrrà una schermata simile alla seguente:

Un'ultima cosa che dobbiamo fare è filtrare l'elenco dei tipi di file consentiti. Per questo abbiamo bisogno di aggiungere un semplice codice come mostrato di seguito su app / uploaders / attachment_uploader.rb

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

Ora avvia il server e visita http: // localhost: 3000. Ora inserisci un formato sbagliato; genererà un messaggio sbagliato come mostrato di seguito -

Per un dettaglio completo su File oggetto, devi passare attraverso il file Ruby Reference Manual.

Action Mailerè il componente Rails che consente alle applicazioni di inviare e ricevere email. In questo capitolo vedremo come inviare un'e-mail utilizzando Rails. Cominciamo a creare un fileemails progetto utilizzando il seguente comando.

tp> rails new mailtest

Questo creerà il framework richiesto per procedere. Ora inizieremo con la configurazione di ActionMailer.

Action Mailer - Configurazione

Di seguito sono riportati i passaggi da seguire per completare la configurazione prima di procedere con il lavoro effettivo:

Vai alla cartella di configurazione del tuo progetto di posta elettronica e apri il file environment.rb e aggiungi la seguente riga in fondo a questo file.

config.action_mailer.delivery_method = :smtp

Indica ad ActionMailer che desideri utilizzare il server SMTP. Puoi anche impostarlo come: sendmail se stai utilizzando un sistema operativo basato su Unix come Mac OS X o Linux.

Aggiungi anche le seguenti righe di codice nella parte inferiore del tuo environment.rb.

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

Sostituisci ogni valore hash con le impostazioni appropriate per il tuo server SMTP (Simple Mail Transfer Protocol). Puoi richiedere queste informazioni al tuo provider di servizi Internet se già non lo sai. Non è necessario modificare il numero di porta 25 e il tipo di autenticazione se si utilizza un server SMTP standard.

È inoltre possibile modificare il formato predefinito del messaggio di posta elettronica. Se preferisci inviare e-mail in HTML invece che in formato testo, aggiungi anche la seguente riga a config / environment.rb -

ActionMailer::Base.default_content_type = "text/html"

ActionMailer :: Base.default_content_type può essere impostato su "text / plain", "text / html" e "text / arricchito". Il valore predefinito è "text / plain".

Il prossimo passo sarà creare un mailer

Genera un bollettino

Utilizzare il seguente comando per generare un mailer come segue:

tp> cd emails
emails> rails generate mailer Usermailer

Questo creerà un file user_mailer.rb nella directory app \ mailer. Controlla il contenuto di questo file come segue:

class Emailer < ActionMailer::Base
end

Creiamo un metodo come segue:

class UserMailer < ApplicationMailer
   default from: '[email protected]'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

default Hash- Questo è un hash dei valori predefiniti per qualsiasi email che invii da questo mailer. In questo caso stiamo impostando: from header su un valore per tutti i messaggi in questa classe. Questo può essere sovrascritto per e-mail
mail - Il messaggio di posta elettronica effettivo, stiamo passando le intestazioni: to e: subject in.

Crea un file chiamato welcome_email.html.erb in app / views / user_mailer /. Questo sarà il modello utilizzato per l'e-mail, formattato in HTML -

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

Successivamente creeremo una parte di testo per questa applicazione come segue:

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

Chiamando il bollettino

Per prima cosa, creiamo un semplice scaffold utente

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

Action Mailer è ben integrato con Active Job in modo da poter inviare e-mail al di fuori del ciclo di richiesta-risposta, in modo che l'utente non debba aspettare -

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

Ora, prova la tua applicazione usando http://127.0.0.1:3000/users/new. Visualizza la seguente schermata e utilizzando questa schermata, sarai in grado di inviare il tuo messaggio a chiunque.

Questo invierà il tuo messaggio e visualizzerà il messaggio di testo "Messaggio inviato con successo" e l'output come segue -

sent mail to [email protected] (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: [email protected]
To: [email protected]
Message-Id: <[email protected]>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

Per ulteriori informazioni su come inviare e-mail utilizzando Rails, vai su ActionMailer .

↰ Previous page Next page ↱