Il merito principale di qualsiasi web designer è essere in grado di capire - e persino organizzare - cosa succede dietro le quinte.

Per lo meno, dovresti prendere alcune lezioni di programmazione. Non sto parlando di linguaggi front-end come HTML e CSS: probabilmente conosci già molte di queste cose. Sto parlando di cose di back-end.

Se sai come gettare le basi, puoi capire meglio come progettare il resto del sito. Il punto è che imparare a programmare ti renderà un designer più erudito. Inoltre, chi non vorrebbe assumere un designer che sappia tutto, dal design allo sviluppo di siti web?

Il trucco è scegliere un punto di partenza. L'apprendimento della programmazione può essere un processo complicato, soprattutto se scegli uno dei linguaggi più difficili come C++ o PHP.

Allora, qual è il posto migliore per iniziare? C'è solo una risposta: Ruby on Rails è uno dei migliori linguaggi e framework di programmazione per l'apprendimento delle basi del design.

Perché Ruby è la scelta migliore?

Per i principianti, Ruby è uno dei linguaggi più facili da imparare, soprattutto se hai un po' di esperienza HTML o CSS che la maggior parte dei designer ha.

Uno dei primi programmi che farai quando inizierai a imparare una lingua è il famigerato Hello World, che prevede la visualizzazione di queste parole sullo schermo.

Con linguaggi come C++, possono esserci da cinque a sette righe di codice solo per visualizzare quelle due parole. Ma se usi Ruby, ci sarà solo una riga e un comando.

Mette "ciao, mondo!"

È tutto! Questo è tutto ciò che serve per digitare le parole "Hello world!" sullo schermo. Abbastanza facile, vero?

Ruby on Rails è anche un linguaggio molto secco. Come uno dei principi di sviluppo, DRY (secco) significa "Non ripetere te stesso" - cioè, non programmare di nuovo l'elemento quando puoi usare quello che hai già creato. Questo rende Ruby un linguaggio di programmazione molto leggero e spesso utilizzato per lo sviluppo, poiché mira a completare un progetto in modo rapido ed efficiente.

Rubino o binari?

Ruby è un linguaggio di programmazione. Rails è un framework che usa Ruby per portare a termine il lavoro. Il framework Ruby on Rails è una raccolta di codice precompilato o prescritto che può aiutare ad accelerare il processo di creazione di nuovi progetti. È stato originariamente creato per sviluppare lo strumento di gestione del progetto Basecamp. Oltre a Basecamp, ci sono altre popolari applicazioni web create con Rails come 500px, ThemeForest e MyFitnessPal.

Una volta compreso come lavorare con il linguaggio Ruby e far funzionare il materiale nel framework Ruby on Rails, puoi iniziare a creare applicazioni web.

Ruby è al suo apice!

Con l'esplosione dei dispositivi mobili e della tecnologia sempre connessa, Ruby è incredibilmente popolare in questo momento. E, probabilmente, sarà così in futuro. L'indice TIOBE classifica Ruby come il 13° linguaggio di programmazione più popolare. In linea con le tendenze emergenti, secondo Indeed.com, anche Ruby sta registrando una domanda sorprendentemente forte.

Indice TIOBE

In ogni caso, qualunque cosa tu scelga - domanda o popolarità - Ruby è piuttosto popolare. Questo lo rende uno dei migliori punti di partenza, perché una volta che hai preso confidenza con la lingua, puoi portare a termine il lavoro abbastanza rapidamente. E questo prima di iniziare a imparare un'altra lingua per espandere le tue abilità.

Ruby ha solide basi!

Alcuni degli altri linguaggi sono in circolazione da più tempo, è vero, ma anche così, il supporto e la documentazione impallidiscono rispetto a ciò che è disponibile per Ruby. Anche altre lingue mancano della coesione sociale attorno a un quadro altamente supportato.

Grazie al framework Ruby On Rails, ci sono già tonnellate di codice preesistente che puoi utilizzare nei tuoi progetti. Ruby Gems, una libreria di framework Ruby, ha oltre 600.000 librerie tra cui scegliere.

Ogni volta che impari qualcosa di nuovo, hai bisogno di molta documentazione e supporto. Ci sono un sacco di posti dove trovare tutorial, tutorial, guide e persino forum di domande e risposte. Se riscontri un problema specifico, una semplice ricerca sul web probabilmente lo risolverà. È importante.

Una documentazione semplice e un facile accesso al supporto sono essenziali quando stai imparando una nuova lingua, quando stai effettivamente imparando qualcosa di nuovo.

Ruby "consente" un maggiore controllo del design

Se sei solo un web designer, la creazione di un sito web può essere un processo lungo e complesso. Quando ti siedi per lavorare con un programmatore e discuti del back-end necessario per il tuo sito, spesso devi sacrificare il front-end affinché tutto funzioni correttamente.

In definitiva, questo può portare a un prodotto che sembra completamente diverso dalla tua visione originale. Al programmatore potrebbe non interessare, ma probabilmente sarà problematico per te.

Non ti imbatterai in problemi di questo tipo se programmi da solo. Non devi dipendere dagli altri per ottenere un progetto finito e avrai una comprensione molto migliore di ciò che può essere ottenuto in termini di sviluppo. Sicuramente ci sono stati un paio di volte in cui gli obiettivi del tuo progetto erano troppo alti per un programmatore o un team di sviluppo? Quando impari una lingua come Ruby, puoi goderti la facilità di comprendere i bisogni e le possibilità, d'altra parte.

Fondamentalmente, Ruby è pensato per essere utilizzato nelle applicazioni web e nello sviluppo web, quindi questo è il posto perfetto per aspiranti web designer. Una volta compreso questo linguaggio e imparato a utilizzare il framework Ruby on Rails, avrai molto più controllo sui tuoi progetti.

Dove imparare Rubino?

Il modo migliore per imparare una lingua è immergersi e lavorare con essa. Ci sono anche molti tutorial e tutorial a cui puoi fare riferimento. Se hai una memoria visiva sviluppata e capisci meglio grazie alle presentazioni visive, vai su YouTube: c'è una vasta selezione di video di formazione.

Se desideri un apprendimento tradizionale in aula, puoi ricevere formazione su siti di apprendimento della programmazione dedicati. Non devi andare all'università o al college per ottenere una laurea.

Una delle mie risorse preferite - e completamente gratuite - per imparare Rails è Rails Tutorial di Michael Hartl. Ti guiderà da un progetto semplice a un progetto complesso al tuo ritmo di apprendimento e potrai iniziare da zero senza alcuna conoscenza di Ruby on Rails.

Indipendentemente dal percorso di apprendimento che scegli, ricorda, solo la pratica porta all'eccellenza. Stabilisci obiettivi personali per trascorrere una certa quantità di tempo ogni giorno lavorando con Ruby. Attieniti a questi obiettivi e sii persistente. Prima di conoscere fino in fondo questa lingua, sarai già un esperto in grado di creare fantastici progetti.

Questa guida copre l'installazione e l'esecuzione di Ruby on Rails.

Dopo averlo letto, scoprirai:

• Come installare Rails, creare una nuova applicazione Rails e collegare la tua applicazione al database.
• La struttura generale di un'applicazione Rails.
• Principi di base di MVC (Model, View Controller) e design basato su RESTful.
• Come generare rapidamente il codice dell'applicazione Rails iniziale.

Ipotesi in questa guida

Questo tutorial è pensato per i principianti che vogliono avviare un'applicazione Rails da zero. Non implica che tu abbia già lavorato con Rails.

Rails è un framework di sviluppo web scritto nel linguaggio di programmazione Ruby. Se non conosci Ruby, potrebbe essere difficile iniziare subito con Rails. Ci sono alcune buone risorse in lingua inglese per imparare Ruby, ad esempio:

Nota che alcune risorse, sebbene siano ancora ottime, coprono ancora le versioni precedenti di Ruby come 1.6, e specialmente 1.8, e non includono alcune delle sintassi che vedrai nel tuo sviluppo quotidiano di Rails.

Cos'è Rails?

Rails è un framework di sviluppo web scritto nel linguaggio di programmazione Ruby. È progettato per semplificare la programmazione di applicazioni Web utilizzando una serie di presupposti su ciò di cui ogni sviluppatore ha bisogno per creare un nuovo progetto. Ti consente di scrivere meno codice durante la programmazione rispetto ad altri linguaggi e framework. Gli sviluppatori di Professional Rails notano anche che lo sviluppo di applicazioni web è più divertente con esso =)

Rails è un software magistrale. Parte dal presupposto che ci sia un modo "migliore" di fare qualcosa, ed è progettato per incoraggiare quel modo - e in alcuni casi anche scoraggiare le alternative. Se studi "The Rails Way", probabilmente scoprirai un aumento significativo della produttività. Se persisti e trasferisci vecchie abitudini da altre lingue nello sviluppo di Rails e provi a utilizzare modelli appresi altrove, la tua esperienza di sviluppo sarà meno felice.

La filosofia Rails include due importanti principi guida:

• Non ripeterti: DRY è un principio di sviluppo software che afferma che "Ogni informazione deve avere una rappresentazione unica, non ridondante e autorevole nel sistema". Non scrivere le stesse informazioni più e più volte, il codice sarà più facile da mantenere e più estensibile e meno bacato.
• Convenzione sulla configurazione: Rails ha opinioni sui modi migliori per fare molte cose in un'applicazione web e queste convenzioni sono impostate per impostazione predefinita, piuttosto che costringerti a modificare numerosi file di configurazione in piccoli dettagli.

Creazione di un nuovo progetto Rails

Il modo migliore per utilizzare questo tutorial è seguirlo passo dopo passo. Tutti i passaggi sono essenziali per eseguire l'applicazione di esempio e non sono necessari codici o passaggi aggiuntivi.

Seguendo questo tutorial, creerai un progetto Rails chiamato blog, un blog web molto semplice. Prima di iniziare a costruire la nostra applicazione, dobbiamo assicurarci che Rails stesso sia installato.

Gli esempi seguenti utilizzano $ per indicare la stringa di input del terminale su sistemi operativi simili a UNIX, sebbene possa essere configurata in modo diverso. Se usi Windows, la riga sarà simile a c: \ source_code>

3.1. Installazione dei binari

Prima di installare Rails, devi verificare che le pre-dipendenze richieste siano installate sul tuo sistema. Questi includono Ruby e SQLite3.

Apri le applicazioni della riga di comando. Su macOS apri Terminal.app, su Windows scegli Esegui dal menu Start e digita cmd.exe. Tutti i comandi che iniziano con il simbolo del dollaro $ devono essere eseguiti sulla riga di comando. Assicurati di avere la versione Ruby corrente installata:

$ rubino -v rubino 2.5.0

Rails richiede l'installazione di Ruby 2.5.0 o successivo. Se il numero di versione è inferiore a questo, sarà necessario installare una nuova copia di Ruby.

Per installare rapidamente Ruby e Ruby on Rails su un sistema, gli utenti Windows possono utilizzare Rails Installer. Ulteriori metodi di installazione per la maggior parte dei sistemi operativi possono essere visualizzati su ruby-lang.org.

Se sei su Windows, devi installare il Ruby Installer Development Kit.

Avrai anche bisogno di un'installazione del database SQLite3.

Molti popolari sistemi operativi simili a UNIX vengono forniti con una versione accettabile di SQLite3. Su Windows, se hai installato Rails utilizzando Rails Installer, hai già installato SQLite. Gli altri utenti possono fare riferimento alle istruzioni di installazione sul sito Web SQLite3. Verifica che sia correttamente installato e incluso nel tuo PERCORSO:

$ sqlite3 --version

Il programma dovrebbe riportare la sua versione.

Per installare Rails, usa il comando gem install fornito da RubyGems:

$ gemma installa binari

Per verificare che tutto sia installato correttamente, è necessario effettuare le seguenti operazioni:

$ rails --version

Se vedi qualcosa come "Rails 6.0.0" puoi continuare.

3.2. Creazione dell'app Blog

Rails viene fornito con una serie di script chiamati generatori, progettati per semplificare la vita dello sviluppatore creando tutto il necessario per iniziare un determinato compito. Uno è il New Application Generator, che fornisce le basi di un'applicazione Rails in modo che tu non debba scriverla da solo.

Per utilizzare questo generatore, apri un terminale, vai nella cartella in cui hai i permessi per creare file e scrivi:

$ rails nuovo blog

Questo creerà un'applicazione Rails denominata Blog nella directory del blog e installerà le gemme le cui dipendenze sono menzionate nel Gemfile utilizzando l'installazione del pacchetto.

Quando si utilizza il sottosistema Windows per Linux, ci sono alcune restrizioni sui messaggi del filesystem, il che significa che le gemme spring e listen dovrebbero essere disabilitate, cosa che può essere eseguita eseguendo rails new blog --skip-spring --skip-listen.

Puoi vedere tutte le possibili opzioni della riga di comando che il generatore di applicazioni Rails accetta eseguendo rails new -h.

Dopo aver creato l'app blog, vai alla sua cartella:

La directory del blog contiene diversi file e cartelle generati automaticamente che definiscono la struttura della tua applicazione Rails. La maggior parte del lavoro in questo tutorial si svolgerà nella cartella dell'app, ma per ora esaminiamo le funzioni di ciascuna cartella che Rails crea nella nuova applicazione predefinita:

Cartella di file	Appuntamento
app /	Contiene controller, modelli, viste, helper, mailer, canali, lavori e risorse per la tua applicazione. Vedremo questa cartella in modo più dettagliato in seguito.
bidone /	Contiene script Rails che avviano la tua applicazione e la directory può contenere anche altri script che usi per configurare, aggiornare, distribuire o eseguire.
configurazione /	Configurazioni del percorso, database della tua applicazione, ecc. Questo è trattato in maggior dettaglio in Configurazione delle applicazioni Rails.
config.ru	Configurazione rack per server basati su rack utilizzati per eseguire l'applicazione. Per ulteriori informazioni su Rack, vedere il sito Web di Rack.
db /	Contiene lo schema corrente del database e le migrazioni del database.
Gemfile Gemfile.lock	Questi file ti consentono di specificare quali dipendenze gems ha bisogno la tua applicazione Rails. Questi file sono usati dalla gemma Bundler. Per ulteriori informazioni su Bundler, vedere il sito Web di Bundler.
lib /	Moduli esterni per la tua applicazione.
tronco d'albero /	File di registro dell'applicazione.
pacchetto.json	Questo file ti consente di specificare quali dipendenze npm sono necessarie per la tua applicazione Rails. Questo file è utilizzato da Yarn. Per ulteriori informazioni su Filati, vedere il sito web Filati.
pubblico /	L'unica cartella accessibile dall'esterno così com'è. Contiene file statici e risorse compilate.
Rakefile	Questo file trova e carica le attività che possono essere eseguite dalla riga di comando. Un'attività specifica è disponibile in tutti i componenti Rails. Invece di modificare il Rakefile, puoi aggiungere le tue attività aggiungendo file alla directory lib / task dell'applicazione.
LEGGIMI.md	Questo è un tutorial introduttivo per la tua applicazione. Dovrebbe essere modificato per dire agli altri cosa fa la tua applicazione, come configurarla, ecc.
Conservazione /	File di archiviazione attivi per il servizio Disco. Questo è trattato nella guida Panoramica sull'archiviazione attiva.
test /	Unit test, infissi e altri apparati di prova. Questo è trattato nel tutorial Testing Rails Applications.
tmp /	File temporanei (come file cache e pid)
venditore /	Un posto per il codice di terze parti. In una tipica applicazione Rails, include gemme esterne.
.gitignore	Questo file dice a git quali file (esplicitamente o selvaggiamente) ignorare. Per ulteriori informazioni sull'ignoranza dei file, vedere GitHub - Ignorare i file.
.versione-ruby	Questo file contiene la versione Ruby predefinita.

Ciao, Rails!

Per prima cosa, mostriamo del testo sullo schermo. Ciò richiede un server in esecuzione per la tua applicazione Rails.

4.1. Avvio del server web

In effetti, hai già un'applicazione Rails funzionante. Per essere sicuro, devi eseguire un server web sulla tua macchina. Questo può essere fatto eseguendo il seguente comando dalla directory del blog:

Se stai usando Windows, devi reindirizzare gli script dalla cartella bin direttamente all'interprete Ruby, cioè ruby ​​​​bin \ rails server.

La compressione delle risorse JavaScript richiede un runtime JavaScript sul sistema e la sua assenza genererà un errore execjs durante la compressione delle risorse. In genere macOS e Windows vengono forniti con un runtime JavaScript installato. therubyrhino è il runtime consigliato per gli utenti JRuby e viene aggiunto al Gemfile se l'applicazione è generata con JRuby. Puoi scoprire tutto sui runtime supportati in ExecJS

Questo avvierà Puma, il server web predefinito con Rails. Per vedere l'app in azione, apri una finestra del browser e vai a http: // localhost: 3000. Dovresti vedere la pagina delle informazioni di Rails predefinita:

Per arrestare il server Web, premere Ctrl + C nel terminale in cui è in esecuzione. Dovresti vedere di nuovo il cursore della riga di comando per verificare che il server sia stato arrestato. Per la maggior parte dei sistemi simili a UNIX, incluso macOS, questo sarà il simbolo del dollaro $. In modalità sviluppo, Rails generalmente non richiede l'arresto del server; tutte le modifiche apportate ai file vengono rilevate automaticamente dal server.

La pagina Welcome Aboard è come un test per una nuova applicazione Rails: mostra che i tuoi programmi sono configurati correttamente per eseguire il rendering della pagina.

4.2. Saluta Rails

Affinché Rails possa dire Hello, devi creare almeno controllore e vyuhu(prestazione).

Lo scopo del titolare è ricevere richieste specifiche per l'applicazione. Instradamento decide quale titolare riceverà quali richieste. Spesso è presente più di un percorso per ciascun controller e percorsi diversi possono essere gestiti in modo diverso. giochi d'azione... Lo scopo di ogni azione è raccogliere informazioni da presentare alla vista.

Lo scopo di una vista è visualizzare queste informazioni in un formato leggibile. Un'importante distinzione da fare è che il luogo in cui vengono raccolte le informazioni è controllore, non una vista. La vista dovrebbe visualizzare solo queste informazioni. Per impostazione predefinita, i modelli di visualizzazione sono scritti in un linguaggio chiamato eRuby (Embedded Ruby), che viene convertito da un loop di richiesta Rails prima di essere inviato all'utente.

Per creare un nuovo controller, avvia il generatore di "controller" e digli che desideri un controller chiamato "Welcome" con un'azione denominata "index", in questo modo:

$ rails genera controller Welcome index

Rails creerà alcuni file e un percorso.

Crea app / controllers / percorso di benvenuto_controller.rb ottieni "benvenuto / indice" invoca erb crea app / views / benvenuto crea app / viste / benvenuto / index.html.erb invoca test_unit crea test / controllers / welcome_controller_test.rb invoca helper crea app / helpers / welcome_helper.rb invoca test_unit invoca asset richiama scss crea app / asset / fogli di stile / welcome.scss

I più importanti di questi sono, ovviamente, il controller che si trova in app/controllers/welcome_controller.rb e la view che si trova in app/views/welcome/index.html.erb.

Apri app / views / welcome / index.html.erb in un editor di testo. Elimina tutto il codice esistente nel file e sostituiscilo con la seguente riga di codice:

Se invii di nuovo il modulo, vedrai qualcosa di simile a quanto segue:

"Primo articolo!", "Testo" => "Questo è il mio primo articolo.") Consentito: falso>

Questa azione ora visualizza i parametri per l'articolo proveniente dal modulo. Tuttavia, questo è ancora inutile. Sì, puoi vedere i parametri, ma essenzialmente non fare nulla con loro.

5.4. Creazione del modello dell'articolo

I modelli in Rails usano un nome singolare e la loro tabella di database corrispondente usa un nome plurale. Rails fornisce un generatore di modelli che la maggior parte degli sviluppatori Rails utilizza per creare nuovi modelli. Per creare un nuovo modello, esegui questo comando nel tuo terminale:

$ rails genera modello Titolo articolo: stringa testo: testo

Con questo comando, diciamo a Rails che vogliamo un modello Article con l'attributo titolo tipo di stringa e attributo testo tipo di testo. Questi attributi verranno automaticamente aggiunti alla tabella articoli e collegati al modello Articolo.

Rails creerà una serie di file in risposta. Ora siamo interessati solo a app / models / article.rb e db / migrate / 20140120191729_create_articles.rb (il tuo nome potrebbe essere leggermente diverso). Quest'ultimo è responsabile della creazione della struttura del database, motivo per cui lo esamineremo ulteriormente.

Active Record è abbastanza intelligente da associare automaticamente i nomi delle colonne agli attributi del modello, il che significa che non è necessario dichiarare gli attributi all'interno dei modelli Rails, Active Record lo farà automaticamente.

5.5. Esecuzione della migrazione

Come hai visto, le rotaie generano il modello generato dal file migrazioni di database nella directory db / migrate. Migrations è una classe Ruby progettata per semplificare la creazione e la modifica di tabelle di database. Rails utilizza i comandi rake per eseguire le migrazioni ed è possibile annullare la migrazione dopo che è stata applicata al database. Il nome del file di migrazione include un timestamp per garantire che vengano eseguiti nell'ordine in cui sono stati creati.

Se guardi nel file db / migrate / YYYYMMDDHHMMSS_create_articles.rb (ricorda, il tuo file ha un nome leggermente diverso), questo è quello che trovi lì:

Class CreateArticoli< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Questa migrazione crea un metodo di modifica che viene chiamato all'avvio di questa migrazione. Le azioni definite in questa migrazione sono anche reversibili, il che significa che Rails sa come annullare le modifiche apportate da questa migrazione nel caso in cui decidi di ripristinarle in seguito. Quando esegui questa migrazione, creerà una tabella di articoli con una colonna di stringhe e una colonna di testo. Creerà anche due campi timestamp per tenere traccia di quando l'articolo è stato creato e aggiornato.

Ora dobbiamo usare il comando rails per avviare la migrazione:

$ rails db: migrate

Rails eseguirà questo comando di migrazione e segnalerà di aver creato la tabella Articoli.

CreaArticoli: migrazione ============================================== = == - create_table (: articoli) -> 0.0019s == CreateArticles: migrati (0.0020s) ========================== === ===========

Dato che stai lavorando nell'ambiente di sviluppo per impostazione predefinita, questo comando si applicherà al database definito nella sezione di sviluppo del tuo file config / database.yml. Se vuoi migrare in un ambiente diverso, ad esempio in produzione, devi passarlo esplicitamente quando invochi il comando: rails db: migrate RAILS_ENV = production.

5.6. Salvataggio dei dati nel controller

Tornando in ArticlesController, è necessario modificare l'azione di creazione per utilizzare il nuovo modello Article per rendere persistenti i dati nel database. Apri app/controller/articoli_controller.rb e modifica l'azione di creazione come segue:

Def create @article = Article.new (params [: article]) @ article.save redirect_to @article end

Ecco cosa sta succedendo qui: ogni modello Rails può essere inizializzato con attributi appropriati che si legheranno automaticamente alle colonne del database corrispondenti. Nella prima riga, facciamo proprio questo (ricorda che params [: article] contiene gli attributi che ci interessano). Quindi @ article.save è responsabile del salvataggio del modello nel database. Infine, reindirizziamo l'utente all'azione show, che definiremo in seguito.

Ti starai chiedendo perché la A in Article.new è maiuscola, sebbene tutti gli altri riferimenti agli articoli in questo tutorial siano tutti minuscoli. In questo contesto, ci riferiamo a una classe chiamata Article, definita in app/models/article.rb. I nomi delle classi in Ruby devono iniziare con una lettera maiuscola.

Ora che ci sono le convalide, chiamare @ article.save su un articolo non valido restituirà false. Se riapri app/controller/articoli_controller.rb, puoi vedere che non stiamo controllando il risultato della chiamata a @ article.save nell'azione di creazione. Se @ article.save fallisce in questa situazione, dobbiamo mostrare nuovamente il modulo all'utente. Per fare ciò, sostituisci il nuovo e crea azioni in app/controller/articoli_controller.rb con queste:

Def new @article = Article.new end def create @article = Article.new (article_params) if @ article.save redirect_to @article else render "nuovo" end private def article_params params.require (: article) .permit (: title ,: testo) fine

La nuova azione ora crea una nuova variabile di istanza denominata @article e vedrai perché in un paio di paragrafi.

Nota che nell'azione create abbiamo usato render invece di redirect_to quando save restituisce false. Il metodo render viene utilizzato in modo che l'oggetto @article venga passato al nuovo modello quando viene visualizzato. Questo rendering viene eseguito come parte della stessa richiesta dell'invio del modulo, mentre redirect_to indica al browser di effettuare un'altra richiesta.

5.11. Aggiornare gli articoli

Abbiamo scoperto la parte "CR" di CRUD. Ora concentriamoci sulla parte "U", aggiornando gli articoli.

Il primo passaggio consiste nell'aggiungere un'azione di modifica a ArticlesController, di solito tra le azioni new e create, come mostrato.

Def new @article = Article.new end def edit @article = Article.find (params [: id]) end def create @article = Article.new (article_params) if @ article.save redirect_to @article else render "new" end fine

La vista conterrà un modulo simile a quello che abbiamo usato durante la creazione di nuovi articoli. Crea un file chiamato app/views/articoli/edit.html.erb e aggiungi quanto segue:

Modifica articolo

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

Ora stiamo indicando il modulo a un'azione di aggiornamento che non è stata ancora definita, ma lo faremo presto.

Il passaggio di un oggetto articolo al metodo form_with imposterà automaticamente l'URL per l'invio del modulo dell'articolo modificato. Questa opzione dice a Rails che vogliamo che questo modulo venga inviato usando PATCH, il metodo HTTP che dovrebbe essere usato per rinnovo risorse secondo il protocollo REST.

Successivamente, è necessario creare un'azione di aggiornamento in app/controller/articles_controller.rb. Aggiungilo tra l'azione create e il metodo privato:

Def create @article = Article.new (article_params) if @ article.save redirect_to @article else render "new" end end def update @article = Article.find (params [: id]) if @ article.update (article_params) redirect_to @article else render "edit" end end private def article_params params.require (: article) .permit (: title,: text) end

Il nuovo metodo, update, viene utilizzato quando si desidera aggiornare un record già esistente e accetta un hash contenente gli attributi che si desidera aggiornare. Come prima, se si verifica un errore durante l'aggiornamento dell'articolo, vogliamo mostrare nuovamente il modulo all'utente.

Abbiamo riutilizzato il metodo article_params definito in precedenza per l'azione create.

Non è necessario passare tutti gli attributi per l'aggiornamento. Ad esempio, se è stato chiamato @ article.update (title: "A new title"), Rails aggiornerà solo l'attributo title, lasciando inalterati tutti gli altri attributi.

<% @articles.each do |article| %> <% end %>

Titolo	Testo
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

E aggiungi anche al modello app / views / items / show.html.erb in modo che il link "Modifica" sia anche sulla pagina dell'articolo. Aggiungi quanto segue alla fine del modello:

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Ed ecco come appare ora la nostra applicazione:

5.12. Utilizzo dei parziali per ripulire la ripetizione nelle viste

La nostra pagina di modifica è molto simile alla nuova pagina, infatti usano lo stesso codice per rendere il modulo. Rimuoviamo questa duplicazione utilizzando una vista parziale. Per convenzione, i file parziali iniziano con un carattere di sottolineatura.

Crea un nuovo file app/views/articoli/_form.html.erb con il seguente contenuto:

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

Aggiorniamo ora la vista app/views/articoli/new.html.erb per utilizzare questo nuovo parziale riscrivendolo nella sua interezza:

Nuovo articolo

<%= render "form" %> <%= link_to "Back", articles_path %>

E lo stesso per l'app/views/articoli/edit.html.erb view:

Modifica articolo

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Eliminazione di articoli

Ora siamo pronti per espandere la parte "D" di CRUD, eliminando dal database. Seguendo la convenzione REST, il percorso per l'eliminazione degli articoli nell'output dei percorsi ferroviari è il seguente:

DELETE /articles/:id(.:format) articoli # destroy

Il metodo di eliminazione dell'instradamento deve essere utilizzato per le rotte che distruggono le risorse. Se lasciato come un normale percorso di get, sarebbe possibile creare i seguenti URL dannosi:

guarda questo gatto!

Usiamo il metodo delete per distruggere le risorse e questa route è associata a un'azione di distruzione in app/controllers/articles_controller.rb che non esiste ancora. Il metodo destroy è solitamente l'ultima azione CRUD nel controller e, come altre azioni CRUD pubbliche, deve essere posizionato prima di qualsiasi metodo privato o protetto. Aggiungiamolo:

Def destroy @article = Article.find (params [: id]) @ article.destroy redirect_to items_path end

L'intero ArticlesController in app/controllers/articles_controller.rb dovrebbe ora assomigliare a questo:

Articoli di classeController< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

È possibile chiamare destroy sugli oggetti Active Record quando si desidera rimuoverli dal database. Tieni presente che non è necessario aggiungere una vista per questa azione, poiché stiamo reindirizzando all'indice.

Elenco articoli

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Titolo	Testo
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Qui usiamo link_to in un modo diverso. Passiamo la route denominata come secondo argomento e options come l'altro argomento. Il metodo:: delete and data: (confirm: "Sei sicuro?") Le opzioni vengono utilizzate come attributi html5, quindi quando si fa clic sul collegamento, Rails mostrerà prima all'utente una finestra di dialogo di conferma e quindi invierà il collegamento utilizzando il metodo di eliminazione . Questo viene fatto utilizzando il file JavaScript rails-ujs, che viene automaticamente incluso nel layout dell'applicazione (app/views/layout/application.html.erb) quando viene generata l'applicazione. Senza questo file, la finestra di dialogo di conferma non verrà visualizzata.

Congratulazioni, ora puoi creare, visualizzare tutti e individualmente, aggiornare e distruggere gli articoli.

Aggiunta di un secondo modello

Ora è il momento di aggiungere un secondo modello all'applicazione. Il secondo modello elaborerà i commenti sugli articoli.

6.1. Generazione del modello

Intendiamo utilizzare lo stesso generatore utilizzato in precedenza durante la creazione del modello Article. Questa volta creeremo un modello di commento contenente un collegamento all'articolo. Esegui il seguente comando nel terminale:

$ rails genera modello Comment commenter: string body: text article: references

Questo comando genera quattro file:

Innanzitutto, dai un'occhiata a app / models / comment.rb:

Commento di classe< ApplicationRecord belongs_to:article end

Questo è molto simile al modello Article che abbiamo visto in precedenza. La differenza è nella riga appartiene_a: articolo, che imposta connessione Registrazione attiva. Vedrai i link nella prossima sezione della guida.

La parola chiave (: references) utilizzata nel comando bash è un tipo di dati speciale per i modelli. Crea una nuova colonna nel database con il nome del modello presentato con _id aggiunto, che può contenere valori numerici. Per capire meglio, analizza il file db/schema.rb dopo aver eseguito la migrazione.

Oltre al modello, Rails ha anche eseguito una migrazione per creare la tabella del database corrispondente:

Class CreateComments< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, null: false, foreign_key: true t.timestamps end end end

La riga t.references crea una colonna numerica denominata article_id, un indice per essa e un vincolo di chiave esterna che punta alla colonna id della tabella degli articoli. Successivamente, avviamo la migrazione:

$ rails db: migrate

Rails è abbastanza intelligente da eseguire solo migrazioni che non sono ancora state eseguite per il database corrente, nel nostro caso vedrai:

CreaCommenti: migrazione ============================================== = = - create_table (: commenti) -> 0.0115s == CreateComments: migrato (0.0119s) ========================== ==== ========

6.2. Collegamento di modelli

I collegamenti a record attivi consentono di dichiarare facilmente una relazione tra due modelli. Nel caso di commenti e articoli, puoi descrivere la relazione come segue:

• Ogni commento appartiene a un articolo.
• Un articolo può avere molti commenti.

In effetti, questo è molto vicino alla sintassi che Rails usa per dichiarare questa relazione. Hai già visto la riga di codice nel modello Comment (app / models / comment.rb) che fa appartenere ogni commento all'articolo:

Commento di classe< ApplicationRecord belongs_to:article end

Devi modificare app/modelli/articolo.rb aggiungendo l'altro lato del link:

Articolo di classe< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Questi due annunci rendono automaticamente disponibile un'ampia varietà di opzioni. Ad esempio, se hai una variabile di istanza @article contenente un articolo, puoi ottenere tutti i commenti appartenenti a quell'articolo in un array chiamando @ article.comments.

6.3. Aggiunta di un percorso per i commenti

Come con il controller di benvenuto, dobbiamo aggiungere un percorso in modo che Rails sappia dove vogliamo andare per vedere i commenti. Apri di nuovo il file config / route.rb e modificalo come segue:

Risorse: gli articoli fanno le risorse: i commenti finiscono

Questo creerà commenti come risorsa annidata negli articoli. Questo è l'altro lato della cattura delle relazioni gerarchiche che esistono tra articoli e commenti.

6.4. Generazione di un controller

Con il modello in mano, rivolgiamo la nostra attenzione alla creazione del controller appropriato. Usiamo lo stesso generatore che abbiamo usato prima:

$ rail generano controller Commenti

Verranno creati quattro file e una directory vuota:

Come con qualsiasi blog, i nostri lettori pubblicheranno i loro commenti subito dopo aver letto l'articolo e, dopo aver aggiunto un commento, verranno reindirizzati alla pagina di visualizzazione dell'articolo e vedranno che il loro commento è già stato riflesso. A questo proposito, il nostro CommentsController serve come mezzo per creare commenti e rimuovere lo spam, se presente.

Innanzitutto, estenderemo il modello di visualizzazione dell'articolo (app/views/articles/show.html.erb) per consentire l'aggiunta di un nuovo commento:

Titolo: <%= @article.title %>

Testo: <%= @article.text %>

Aggiungi un commento:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Questo aggiungerà un modulo alla pagina di visualizzazione dell'articolo, creando un nuovo commento quando viene chiamata l'azione di creazione su CommentsController. La chiamata form_with qui utilizza un array, che creerà un percorso annidato come /articoli / 1 /commenti.

Scriviamo create in app/controllers/comments_controller.rb:

Commenti di classeController< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

Questo è un po' più complicato di quello che hai visto nel controller dell'articolo. Questo è un effetto collaterale dell'allegato che hai configurato. Ogni richiesta di commento tiene traccia dell'articolo a cui è allegato il commento, quindi per prima cosa risolviamo il problema del recupero dell'articolo chiamando find sul modello Article.

Inoltre, il codice sfrutta alcuni dei metodi disponibili per le relazioni. Usiamo il metodo create su @ article.comments per creare e salvare un commento. Questo collega automaticamente il commento in modo che appartenga a un articolo specifico.

Una volta creato un nuovo commento, riportiamo l'utente all'articolo originale utilizzando l'helper article_path (@article). Come abbiamo visto, chiama l'azione show su ArticlesController, che a sua volta esegue il rendering del modello show.html.erb. Qui è dove vogliamo visualizzare i commenti, quindi aggiungiamo quanto segue a app/views/articoli/show.html.erb.

Titolo: <%= @article.title %>

Testo: <%= @article.text %>

Commenti

<% @article.comments.each do |comment| %>

Commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

<% end %>

Aggiungi un commento:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Ora puoi aggiungere articoli e commenti al tuo blog e visualizzarli nei posti giusti.

refactoring

Ora che abbiamo articoli e commenti funzionanti, diamo un'occhiata al modello app/views/articles/show.html.erb. È diventato lungo e scomodo. Usiamo i parziali per scaricarlo.

7.1. Rendering di collezioni parziali

Innanzitutto, facciamo un commento parziale che mostri tutti i commenti per l'articolo. Crea un file app / views / comments / _comment.html.erb e inserisci quanto segue:

Commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

Quindi puoi cambiare app/views/articoli/show.html.erb in questo modo:

Titolo: <%= @article.title %>

Testo: <%= @article.text %>

Commenti

<%= render @article.comments %>

Aggiungi un commento:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Questo ora renderà l'app /views/comments/_comment.html.erb parziale una volta per ogni commento nella raccolta @article.comments. Poiché il metodo render itera sulla raccolta @ article.comments, assegna ogni commento a una variabile locale con lo stesso nome del parziale, nel nostro caso commento, che è disponibile nel parziale da visualizzare.

7.2. Rendering di una forma in modo parziale

Spostiamo anche la nuova sezione dei commenti nel nostro parziale. Ancora una volta, crea un file app/views/comments/_form.html.erb contenente:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

Quindi cambia app/views/articoli/show.html.erb come segue:

Titolo: <%= @article.title %>

Testo: <%= @article.text %>

Commenti

<%= render @article.comments %>

Aggiungi un commento:

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Il secondo render definisce solo il modello per il parziale che vogliamo rendere, commenti/form. Rails è abbastanza intelligente da mettere un trattino basso su questa riga e rendersi conto che volevi rendere il file _form.html.erb nella directory app/views/comments.

L'oggetto @article è disponibile su qualsiasi parziale reso nella vista, poiché lo abbiamo definito come variabile di istanza.

Eliminazione dei commenti

Un'altra caratteristica importante del blog è la possibilità di rimuovere lo spam. Per fare ciò, è necessario inserire un collegamento nella vista e un'azione di distruzione nel CommentsController.

Commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

Facendo clic su questo nuovo collegamento "Destroy Comment" verrà eseguito DELETE / articoli /: article_id / commenti /: id nel nostro CommentsController, che verrà quindi utilizzato per trovare il commento che vogliamo eliminare, quindi aggiungiamo un'azione di distruzione al nostro controller (app / controllers / commenti_controller.rb):

Commenti di classeController< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

L'azione di distruzione troverà l'articolo che stiamo visualizzando, troverà il commento nella raccolta @ article.comments, quindi lo rimuoverà dal database e ci riporterà a visualizzare l'articolo.

8.1. Rimozione di oggetti correlati

Se elimini un articolo, devono essere eliminati anche i commenti associati, altrimenti occuperanno semplicemente spazio nel database. Rails ti consente di utilizzare l'opzione dipendente su un collegamento per raggiungere questo obiettivo. Modifica il modello dell'articolo, app/modelli/articolo.rb, come segue:

Articolo di classe< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Sicurezza

9.1. Autenticazione di base

Se pubblichi il tuo blog online, chiunque può aggiungere, modificare ed eliminare articoli o eliminare commenti.

Rails fornisce un sistema di autenticazione HTTP di base che funziona bene per questa situazione.

In ArticlesController, abbiamo bisogno di un modo per bloccare l'accesso a varie azioni se l'utente non è autenticato. Qui possiamo usare il metodo Rails http_basic_authenticate_with per consentire l'accesso alle azioni richieste, se il metodo lo consente.

Per utilizzare un sistema di autenticazione, lo definiremo nella parte superiore del nostro ArticlesController in app/controllers/Articles_controller.rb. Nel nostro caso, vogliamo che l'utente sia autenticato per ogni azione tranne index e show, quindi scriviamo in questo modo:

Articoli di classeController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

Vogliamo anche consentire solo agli utenti autenticati di eliminare i commenti, quindi nel CommentsController (app/controller/comments_controller.rb) scriveremo:

Commenti di classeController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

Ora, se provi a creare un nuovo articolo, incontrerai una sfida di autenticazione di base HTTP:

Sono disponibili anche altri metodi di autenticazione per le applicazioni Rails. Due componenti aggiuntivi popolari per Rails sono Devise e Authlogic, tra gli altri.

9.2. Altre riflessioni sulla sicurezza

La sicurezza, soprattutto nelle applicazioni web, è un'area vasta e dettagliata. La protezione della tua applicazione Rails è trattata in modo più dettagliato nella guida Securing Rails Applications Il modo più semplice per lavorare con Rails è memorizzare tutti i dati esterni in UTF-8. In caso contrario, le librerie Ruby e Rails saranno spesso in grado di convertire i tuoi dati nativi in ​​UTF-8, ma questo non funziona sempre in modo affidabile, quindi è meglio assicurarsi che tutti i dati esterni siano UTF-8.

Se commetti un errore in quest'area, il sintomo più comune è un diamante nero con un punto interrogativo all'interno che appare nel browser. Un altro sintomo comune è la visualizzazione di caratteri come "ü" invece di "ü". Rails adotta una serie di passaggi interni per mitigare i casi comuni di problemi che possono essere rilevati e risolti automaticamente. Tuttavia, se ci sono dati esterni che non sono archiviati in UTF-8, può portare a questo tipo di problemi che non possono essere rilevati automaticamente da Rails e risolti.

Le due origini dati più comuni che non sono in UTF-8 sono:

• Il tuo editor di testo: la maggior parte degli editor di testo (come TextMate) salva i file come UTF-8 per impostazione predefinita. Se il tuo editor di testo non esegue questa operazione, i caratteri speciali inseriti nei tuoi modelli (come é) potrebbero apparire come un rombo con un punto interrogativo nel browser. Questo vale anche per i tuoi file di traduzione i18N. La maggior parte degli editor che non impostano l'impostazione predefinita su UTF-8 (come alcune versioni di Dreamweaver) offrono un modo per modificare le impostazioni predefinite su UTF-8. Fai questo.
• Il tuo database: Rails converte i dati dal tuo database in UTF-8 per impostazione predefinita al confine. Tuttavia, se il database non utilizza internamente UTF-8, potrebbe non essere in grado di memorizzare tutti i caratteri inseriti dall'utente. Ad esempio, se il database utilizza internamente Latin-1 e l'utente immette caratteri russi, ebraici o giapponesi, i dati andranno persi non appena verranno immessi nel database. Se possibile, usa UTF-8 come memoria interna nel tuo database.

Crea applicazioni reali usando Ruby on Rails. Potresti aver provato Ruby on Rails, ma l'hai trovato troppo complicato e senti di aver bisogno di un'introduzione più completa. Forse il tuo capo o cliente ti ha approfondito con un progetto Ruby on Rails e hai bisogno di conoscere rapidamente Rails? O forse hai deciso di aggiungere lo sviluppo web e Ruby on Rails al tuo curriculum. Se è così, sei nel posto giusto. Questo corso ti insegna come creare applicazioni web usando Ruby on Rails.

Perché Ruby on Rails?

Ruby on Rails è un modo veloce ed efficiente per sviluppare applicazioni web. Semplifica le attività ripetitive comuni che richiedono molto tempo per essere create in altre lingue. È molto più facile ottenere un prodotto di alta qualità completato in Ruby on Rails che in altre lingue.

Poiché il framework è maturo, ci sono un sacco di progetti / codice open source che puoi usare che sono estremamente potenti e ti danno davvero il vantaggio nella creazione di applicazioni web robuste.

Inoltre, utilizza il linguaggio di programmazione Ruby. Il codice Ruby si legge come l'inglese, il che lo rende molto più facile da capire se stai appena iniziando con la programmazione. Come lingua tipizzata dinamicamente, Ruby non ha tutte le regole ferree che hanno le altre lingue ed è per molti versi simile a una lingua parlata. Questo ti dà la flessibilità di risolvere i problemi in un modo più umano rispetto ad altri linguaggi di programmazione.

Cosa è coperto?

Alcune delle funzionalità coperte dal corso includono ...

Git Basics, Rails core "7 metodi" e come fanno "CRUD", Rails Routing, Strong Parameters, Custom Callback, Custom Validation, Partials,

Bootstrap 4, Rails Generators, Autenticazione utente, Autenticazione utente, Gestione dei contenuti, Distribuzione, Caricamento del database, Invio/ricezione di e-mail tramite l'app Rails, Configurazione di Sidekiq, Configurazione di Redis su Heroku e server privato, Installazione di modelli, Messaggi di convalida personalizzati, aggiunta di risorse alla Rails Pipeline, caricando immagini sul tuo server, caricando su AWS, aggiungendo WYSIWYG: quello che vedi è ciò che ottieni dall'editor e molto altro!

Perché iscriversi a questo corso è la decisione migliore che puoi prendere.

Questi corsi utilizzano esempi semplici per completare compiti complessi. L'obiettivo è farti capire esattamente cosa stai facendo e le ragioni per cui, piuttosto che inserire codice che non capisci. Nessun codice viene oscurato in quanto è importante che tu capisca cosa fa ogni riga.

Al termine di questo corso, avrai le competenze necessarie per creare le tue applicazioni web utilizzando Ruby on Rails.

Prima ti iscrivi a questo corso, prima avrai le competenze e le conoscenze necessarie per aumentare la tua esperienza. Gli sviluppatori di Ruby on Rails sono molto richiesti! Perché non iniziare oggi stesso su Ruby on Rails?

In questo articolo, voglio mostrarti come creare una semplice applicazione di database MySQL in Ruby on Rails 3. Considerala come una guida passo passo per i programmatori Rails alle prime armi.

Quindi, per funzionare, abbiamo bisogno di binari e rubini installati. Ho avuto un problema con quest'ultimo ieri, quindi ho dovuto rimuovere il pacchetto rubygems1.8, non è chiaro come sia finito nel sistema e installare rubygems1.9.Vi ricordo che sto sviluppando su Ubuntu, anche se per Windows i comandi della console Rails saranno gli stessi. Come ambiente di sviluppo utilizzo NetBeans con un plugin per Ruby on Rails. Il mio collega ha scritto abbastanza bene sull'installazione.

Controllo dei collegamenti

Assicurati che la directory /usr/bin contenga rails, rake, ruby, collegamenti simbolici bundler ai file dalla directory /usr/local/ruby ​​/bin. Per visualizzare i collegamenti utilizzare il comando:

a seconda di cosa vuoi filtrare.

Crea un'applicazione

Ho creato una directory speciale per le mie applicazioni Ruby.

mkdir / home / andrey / ruby
cd /home.andrey/ruby

Rails ha molte utility per console che rendono le cose molto più semplici, specialmente la prototipazione. Per creare un'applicazione utilizzando mysql come database, eseguire il comando:

app è il nome della nostra nuova applicazione. Dopo aver eseguito il comando, vedremo come rails ci ha reso uno scheletro della futura applicazione.

[e-mail protetta]: ~ / ruby ​​# rails new app -d mysql
creare
crea README
creare file rake
creare config.ru
creare .gitignore
creare Gemfile
creare app
creare app / controller / application_controller.rb
crea app / helper / application_helper.rb
creare app / mailer
creare app/modelli
crea app / viste / layout / application.html.erb
creare configurazione
crea config / route.rb
crea config / application.rb
crea config / ambiente.rb
creare configurazione / ambienti
crea config/ambienti/sviluppo.rb
creare config/ambienti/produzione.rb
crea config/ambienti/test.rb
creare config / inizializzatori
crea config/inizializzatori/backtrace_silencers.rb
crea config/inizializzatori/inflections.rb
crea config/inizializzatori/mime_types.rb
crea config/inizializzatori/secret_token.rb
crea config/inizializzatori/session_store.rb
crea configurazione / locale
crea config / locales / en.yml
crea config / boot.rb
crea config / database.yml
creare db
creare db / seed.rb
creare un documento
crea documento / README_FOR_APP
creare lib
creare lib / task
crea lib / task / .gitkeep
crea registro
crea log / server.log
creare log / produzione.log
creare log / sviluppo.log
crea log / test.log
creare pubblico
crea pubblico / 404.html
creare pubblico / 422.html
crea pubblico / 500.html
crea public / favicon.ico
crea public / index.html
crea public / robots.txt
creare pubblico / immagini
creare pubblico / immagini / rails.png
creare pubblico / fogli di stile
creare public / fogli di stile / .gitkeep
creare public/javascripts
creare public/javascripts/application.js
creare public/javascripts/controls.js
crea public/javascripts/dragdrop.js
crea public/javascripts/effects.js
creare public/javascripts/prototipo.js
creare public / javascript / rails.js
creare script
creare script / binari
creare test
creare test / infissi
creare test / funzionale
creare test/integrazione
creare test / prestazioni / navigazione_test.rb
crea test / test_helper.rb
creare test / unità
creare tmp
creare tmp / sessioni
creare tmp / socket
crea tmp/cache
creare tmp / pids
creare fornitore/plugin
crea fornitore / plugin / .gitkeep

Entriamo nella cartella con esso e installiamo le gemme necessarie. Le gemme sono librerie plug-in necessarie per un progetto (analoghe a PECL e PEAR di PHP).

Successivamente, la console visualizzerà qualcosa del genere:

[e-mail protetta]: ~/ruby/app> sudo bundle install
Usando il rastrello (0.8.7)
Utilizzo di abstract (1.0.0)
Utilizzo di activesupport (3.0.0)
Utilizzo del generatore (2.1.2)
Utilizzo di i18n (0.4.2)
Utilizzo di activemodel (3.0.0)
Utilizzo di erubis (2.6.6)
Utilizzo della cremagliera (1.2.1)
Utilizzo del montaggio su rack (0.6.13)
Utilizzo del test del rack (0.5.6)
Utilizzo di tzinfo (0.3.23)
Utilizzo del pacchetto di azioni (3.0.0)
Utilizzo di tipi mime (1.16)
Utilizzo del poliglotta (0.3.1)
Utilizzo della cima degli alberi (1.4.8)
Utilizzo della posta (2.2.9)
Utilizzo di actionmailer (3.0.0)
Utilizzo di arel (1.0.1)
Utilizzo di activerecord (3.0.0)
Utilizzo di activeresource (3.0.0)
Utilizzo del bundler (1.0.3)
Utilizzo di mysql2 (0.2.6)
Usando thor (0.14.4)
Utilizzo dei binari (3.0.0)
Utilizzo dei binari (3.0.0)
Il tuo pacchetto è completo! Usa `bundle show` per vedere dove è installata una gemma in bundle.

Ciò significa che tutte le gemme sono installate e connesse. Se manca qualcosa, bundle stesso li scaricherà da rubygems e li installerà. Questo è quello che mi è mancato in php per molto tempo, infatti risulta il programma di installazione del progetto. L'elenco delle gemme dipendenti si trova nel Gemfile alla radice del progetto.

Configurazione

Ora dobbiamo specificare i dettagli di accesso al database del nostro progetto. Apri il progetto in NetBeans: Nuovo progetto -> Ruby -> Applicazione Ruby on Rails con sorgente esistente. Indichiamo il percorso, nel mio caso sarà (/home/andrey/ruby/app) e il nome del progetto (app). Per la piattaforma Ruby, selezioniamo quella installata sul sistema, non quella integrata in NetBeans. Fare clic su Fine e il progetto viene creato. Apri la pseudo-cartella Configurazione e il file database.yml. Qui è necessario specificare username e password per accedere al database, preferibilmente per tutti e tre gli ambienti (sviluppo, test, produzione). L'ambiente è l'ambiente in cui verrà eseguita la nostra applicazione,

• sviluppo: il computer dello sviluppatore,
• produzione - server di produzione,
• test: lavora in modalità di test su un server di integrazione continua o sul computer di un tester.

rails generate model Nome utente: string hash_password: string salt: string

Puoi vedere immediatamente cosa ha generato Rails per noi:

invoca active_record
crea db / migra / 20101107054200_create_users.rb
crea app/modelli/user.rb
invoca test_unit
crea test / unità / user_test.rb
crea test/infissi/users.yml

Ottimo, ora dobbiamo creare un database. Per questo eseguiamo:

[e-mail protetta]: ~ / ruby ​​/ app $ rake db: create
(in /home/andrey/ruby/app)
[e-mail protetta]: ~ / ruby ​​/ app $ rake db: migrate
(in /home/andrey/ruby/app)
== CreateUsers: migrazione =========================================== == =====
- create_table (: utenti)
-> 0.0061s
== CreateUsers: migrati (0,0063s) ======================================= ==

La console visualizza i dati aggiunti. Guardiamo in phpmyadmin e vediamo i nuovi database app_development e app_test, così come le tabelle al loro interno. Ora è il momento di aggiungere dati reali. Per fare ciò, esegui la console dei binari

La console non è solo una console, ma una console IRB nel contesto della tua applicazione. Creiamo due utenti come esempio:

[e-mail protetta]: ~ / ruby ​​/ app $ rails console
Caricamento ambiente di sviluppo (Rails 3.0.0)
irb (principale): 001: 0> utente1 = Utente.nuovo
=> #
irb (principale): 002: 0> user1.name = "andrey"
=> "Andrey"
irb (principale): 003: 0> user1.save
=> vero
irb (principale): 004: 0> utente2 = Utente.nuovo
=> #
irb (principale): 005: 0> user2.name = "vasiliy"
=> "Vasilij"
irb (principale): 006: 0> user2.save
=> vero

irb (principale): 007: 0> uscita
[e-mail protetta]: ~ / rubino / app $

Diamo un'occhiata al database, e infatti abbiamo due utenti. Nota che Rails stesso ha aggiunto le colonne della chiave primaria e i campi created_at (data di creazione) e aggiornato_at (data di modifica) al modello.

Abbiamo il modello, anche i dati. È ora di lanciare la nostra applicazione.

[e-mail protetta]: ~ / ruby ​​/ app $ rails server
=> Avvio di WEBrick
=> Applicazione Rails 3.0.0 in fase di sviluppo su http://0.0.0.0:3000
=> Chiama con -d per staccare
=> Ctrl-C per spegnere il server
INFO WEBrick 1.3.1
INFO rubino 1.9.2 (2010-08-18)
INFO WEBrick :: HTTPServer # start: pid = 4193 port = 3000

L'applicazione è in esecuzione, aprire il browser all'indirizzo e vedere la pagina di prova.

Ottimo, l'app funziona. Ma mostra una normale pagina HTML dalla cartella /public/index.html. E vogliamo dinamico. Apriamo la seconda finestra della console (perché nella prima abbiamo il ver-server Ruby in esecuzione - WebRick), andiamo nella cartella con il progetto e digitiamo il seguente comando:

[e-mail protetta]: ~ / ruby ​​/ app $ rails generano l'indice dell'indice del controller
creare app/controller/index_controller.rb
percorso ottiene "indice / indice"
invocare erb
creare app / visualizzazioni / indice
crea app/views/index/index.html.erb
invoca test_unit
creare test / funzionale / index_controller_test.rb
invocare aiutante
crea app/helper/index_helper.rb
invoca test_unit
crea test / unità / helper / index_helper_test.rb
[e-mail protetta]: ~ / rubino / app $

Con questo abbiamo creato il controller Index, in esso l'azione Index e il tipo di questa azione index.html.erb Facciamo un Refresh (F5) in NetBeans e guardiamo i nostri file. Meraviglioso. Ora abbiamo bisogno di reindirizzare in qualche modo il percorso per la pagina principale all'azione del controller che abbiamo creato. Apri il file route (Configuration / route.rb) e decommenta la seguente riga lì:

# Puoi fare in modo che la root del tuo sito venga instradata con "root"
# ricordati solo di eliminare public / index.html.
root: to => "benvenuto # indice"

Ma invece di benvenuto, scriviamo anche index. Bene, sono abituato da Zend Framework che il controller e l'azione sono denominati index per impostazione predefinita. Non dimenticare di eliminare (o rinominare) il file public / index.html).

root: to => "indice # indice"

Aggiorniamo la pagina nel browser e vediamo che la nostra vista è ora visualizzata.

Indice # indice

Bene. Ora puoi codificare Andiamo al nostro controller appena creato (Controller -> index_controller.rb) e scrivi lì il seguente testo di azione:

class IndexController< ApplicationController
indice def
@users = User.find (: all)
fine
fine

Ora apri la vista Views / index / index.html.erb e scrivi il seguente codice lì:

Indice # indice

Trovami in app/views/index/index.html.erb

<% for user in @users -%>
<%=user.name%>

<% end %>

Questo dice a Rails di esaminare l'array di utenti e di visualizzare i loro nomi. Aggiorniamo la pagina e vediamo l'elenco degli utenti in fondo.

Indice # indice

Trovami in app/views/index/index.html.erb

andrey
vasiliy

Bene! L'applicazione è stata creata!

Grazie!

Se questo articolo ti ha aiutato, o vuoi supportare la mia ricerca e il mio blog, ecco il modo migliore per farlo:

Ruby ha iniziato lo sviluppo il 23 febbraio 1993 ed è stato rilasciato nel 1995. Il nome è ispirato al linguaggio Perl, da cui molte sintassi e semantica sono mutuate in Ruby (pearl - "pearl", ruby ​​- "ruby"). L'obiettivo dello sviluppo era creare un linguaggio di programmazione interpretato "vero orientato agli oggetti", facile da sviluppare.

Il linguaggio ha un'implementazione multithreading indipendente dal sistema operativo, una forte tipizzazione dinamica, un garbage collector e molte altre funzionalità. L'implementazione multipiattaforma dell'interprete linguistico è completamente gratuita.

Ruby on Rails (RoR) è un framework scritto nel linguaggio di programmazione Ruby. Implementa il modello architetturale Model-View-Controller per le applicazioni Web e fornisce anche l'integrazione con il server Web e il server di database. È un software open source e concesso in licenza con la licenza MIT.

Per aiutarti a esplorare queste tecnologie, abbiamo compilato una selezione di libri. Come sempre, se conosci un libro che non è stato incluso in questo materiale, condividilo nei commenti.

Questo libro è per coloro che vogliono scrivere Ruby come un professionista. Spiega come progettare bellissime API e lavorare con tecniche di programmazione funzionale. Il libro non è adatto ai principianti, ma per chi conosce già Ruby tornerà sicuramente utile.

Lo scopo di questo libro è insegnare ai lettori come usare efficacemente la lingua Ruby. Questo libro tratta Ruby 2.1. La pubblicazione contiene circa 400 esempi diversi, accompagnati da una chiara esposizione del problema e della sua soluzione con commenti dettagliati.

Il libro ha una soglia di ingresso abbastanza bassa. Non è necessario conoscere le basi dello sviluppo web per impararlo. Il libro prende materiale su Ruby on Rails, un framework popolare per lo sviluppo di applicazioni web, da zero. L'autore Michael Hartl, oltre a Ruby on Rails, fa conoscere al lettore le basi del linguaggio Ruby stesso, il linguaggio di query SQL, CSS, HTML. Il libro presta molta attenzione all'uso pratico delle capacità del framework. Puoi anche leggere un frammento del libro.

E questo libro è utile per i principianti. La sua complessità aumenta in modo crescente e in ogni sezione successiva vengono utilizzate le abilità apprese nelle precedenti.

Con "Learning Ruby" imparerai in modo facile e divertente in pratica tutte le caratteristiche di questo linguaggio, che dapprima ha rapidamente conquistato il cuore dei programmatori in California, e poi in Russia.

Dopo aver letto questo libro, imparerai a scrivere codice elegante che sfrutti tutte le sue caratteristiche uniche.

Questo libro esamina in dettaglio gli aspetti interni del linguaggio Ruby. Il lettore non ha bisogno di conoscere Ruby stesso, ma la conoscenza del C e, in particolare, dei principi OOP sarà un enorme vantaggio.

Questo libro è un'ottima introduzione a Ruby. Copre tutte le nozioni di base di cui hai bisogno, dall'installazione della lingua alla gestione dei file e all'OOP. Ogni argomento è fornito con esempi chiari.

Questo libro tratta una delle caratteristiche più interessanti di Ruby: i blocchi. Sono simili a chiusure e lambda e vengono utilizzati sia in strutture linguistiche semplici come i blocchi che in trucchi complessi.

Questo libro è diviso in diverse sezioni, di varia complessità. Copre prima la configurazione e le funzionalità di base di Ruby, quindi parla della libreria standard e dei temi avanzati.