Ruby on Rails - Szybki przewodnik

Co to jest Ruby?

Zanim zaczniemy jeździć na Railsach, podsumujmy kilka punktów Rubiego, który jest podstawą Railsów.

Ruby to udane połączenie -

Konceptualna elegancja Smalltalka,
Łatwość obsługi i nauki języka Python oraz
Pragmatyzm Perla.

Ruby jest -

Język programowania wysokiego poziomu.
Zinterpretowany jak Perl, Python, Tcl / TK.
Zorientowany obiektowo, jak Smalltalk, Eiffel, Ada, Java.

Dlaczego Ruby?

Rubin powstał w Japonii, a teraz zyskuje popularność także w USA i Europie. Na jego popularność składają się następujące czynniki -

Łatwe do nauki
Open source (bardzo liberalna licencja)
Bogate biblioteki
Bardzo łatwe do przedłużenia
Prawdziwie zorientowany obiektowo
Mniej kodowania i mniej błędów
Pomocna społeczność

Chociaż mamy wiele powodów, aby używać Rubiego, istnieje również kilka wad, które warto rozważyć przed wdrożeniem Rubiego:

Performance Issues - Chociaż rywalizuje z Perlem i Pythonem, nadal jest językiem interpretowanym i nie możemy go porównać z językami programowania wysokiego poziomu, takimi jak C czy C ++.
Threading model- Ruby nie używa natywnych wątków. Wątki Ruby są symulowane w maszynie wirtualnej, a nie działają jako natywne wątki systemu operacyjnego.

Przykładowy kod Ruby

Oto przykładowy kod Ruby do wydrukowania „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 - To da następujący wynik -

Hello Ruby!

Wbudowany Ruby

Ruby dostarcza program o nazwie ERB (Embedded Ruby), napisany przez Seki Masatoshiego . ERB pozwala na umieszczanie kodów Ruby w pliku HTML. ERB czyta dalej, słowo w słowo, a następnie w pewnym momencie, gdy napotka kod Ruby osadzony w dokumencie, rozpoczyna wykonywanie kodu Ruby.

Aby przygotować dokument ERB, musisz wiedzieć tylko dwie rzeczy -

Jeśli chcesz, aby jakiś kod Ruby został wykonany, umieść go między <% i %>.
Jeśli chcesz, aby wynik wykonania kodu został wydrukowany jako część danych wyjściowych, umieść kod między <%= i %>.

Oto przykład. Zapisz kod w pliku erbdemo.rb. Zauważ, że plik Ruby będzie miał rozszerzenie.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>

Teraz uruchom program za pomocą narzędzia wiersza poleceń erb.

tp> erb erbdemo.rb

To da następujący wynik -

<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>

Co to jest Rails?

Niezwykle produktywna struktura aplikacji internetowych.
Napisane w Ruby przez Davida Heinemeiera Hanssona.
Możesz stworzyć aplikację internetową co najmniej dziesięć razy szybciej w Railsach niż w typowym frameworku Java.
Framework Ruby o otwartym kodzie źródłowym do tworzenia aplikacji internetowych opartych na bazach danych.
Skonfiguruj swój kod za pomocą schematu bazy danych.
Nie jest wymagana faza kompilacji.

Pełna struktura stosu

Zawiera wszystko, co jest potrzebne do stworzenia aplikacji internetowej opartej na bazie danych, przy użyciu wzorca Model-View-Controller.
Struktura pełnego stosu oznacza, że wszystkie warstwy są zbudowane tak, aby bezproblemowo współpracowały z mniejszą ilością kodu.
Wymaga mniej wierszy kodu niż inne frameworki.

Konwencja nad konfiguracją

Railsy unika plików konfiguracyjnych na rzecz konwencji, odbić i dynamicznych rozszerzeń środowiska uruchomieniowego.
Twój kod aplikacji i działająca baza danych zawierają już wszystko, co Railsy muszą wiedzieć!

Mocne strony szyn

Railsy są wyposażone w funkcje, które zwiększają produktywność, a wiele z poniższych funkcji opiera się na sobie nawzajem.

Metaprogramowanie

Tam, gdzie inne frameworki używają obszernego generowania kodu od zera, framework Rail używa technik metaprogramowania do pisania programów. Ruby jest jednym z najlepszych języków do metaprogramowania, a Railsy dobrze wykorzystują tę możliwość. Railsy również używają generowania kodu, ale znacznie bardziej polegają na metaprogramowaniu do podnoszenia ciężarów.

Rekord aktywny

Railsy wprowadzają framework Active Record, który zapisuje obiekty w bazie danych. Wersja modułu Active Record Railsowego wykrywa kolumny w schemacie bazy danych i automatycznie dołącza je do obiektów domeny za pomocą metaprogramowania.

Konwencja dotycząca konfiguracji

Większość platform programistycznych dla .NET lub Java wymusza pisanie stron z kodem konfiguracyjnym. Jeśli zastosujesz się do sugerowanych konwencji nazewnictwa, Railsy nie potrzebują dużo konfiguracji.

Rusztowanie

Często tworzysz tymczasowy kod na wczesnych etapach programowania, aby pomóc w szybkim uruchomieniu aplikacji i zobaczyć, jak współpracują ze sobą główne komponenty. Railsy automatycznie tworzą większość potrzebnych rusztowań.

Wbudowane testy

Railsy tworzą proste testy automatyczne, które możesz następnie rozszerzyć. Railsy zapewniają również pomocniczy kod zwany wiązkami i urządzeniami, który ułatwia pisanie i uruchamianie przypadków testowych. Ruby może następnie wykonać wszystkie testy automatyczne za pomocą narzędzia rake.

Trzy środowiska

Railsy oferują trzy domyślne środowiska: programistyczne, testowe i produkcyjne. Każdy zachowuje się nieco inaczej, ułatwiając cały cykl tworzenia oprogramowania. Na przykład Railsy tworzą nową kopię bazy danych Test dla każdego przebiegu testu.

Aby stworzyć aplikację internetową przy użyciu Ruby on Rails Framework, musisz zainstalować następujące oprogramowanie -

Ruby
Rails Framework
Serwer WWW
System baz danych

Zakładamy, że masz już zainstalowany serwer WWW i system baz danych na swoim komputerze. Możesz użyć WEBrick Web Server, który jest dostarczany z Rubim. Jednak większość witryn internetowych używa serwerów WWW Apache lub lightTPD w środowisku produkcyjnym.

Rails współpracuje z wieloma systemami baz danych, w tym MySQL, PostgreSQL, SQLite, Oracle, DB2 i SQL Server. Aby skonfigurować bazę danych, zapoznaj się z odpowiednią instrukcją konfiguracji systemu bazy danych.

Spójrzmy na instrukcje instalacji dla Railsów w systemie Windows i Linux.

Instalacja szyn w systemie Windows

Postępuj zgodnie z instrukcjami podanymi poniżej, aby zainstalować Ruby on Rails.

Krok 1: Sprawdź wersję Ruby

Najpierw sprawdź, czy masz już zainstalowany Ruby. Otwórz wiersz polecenia i wpiszruby -v. Jeśli Ruby odpowie i pokaże numer wersji 2.2.2 lub wyższy, wpiszgem --version. Jeśli nie pojawia się błąd, pomińInstall Rubykrok. W przeciwnym razie zainstalujemy nowy Ruby.

Krok 2: Zainstaluj Rubiego

Jeśli Ruby nie jest zainstalowany, pobierz pakiet instalacyjny z rubyinstaller.org. Podążaj zadownloadlink i uruchom wynikowy instalator. To jest plik exerubyinstaller-2.2.2.x.exei zostanie zainstalowany jednym kliknięciem. Jest to bardzo mały pakiet, a wraz z nim otrzymasz RubyGems. Proszę sprawdzićRelease Notes aby uzyskać więcej szczegółów.

Krok 3: Zainstaluj szyny

Install Rails - Po załadowaniu Rubygems możesz zainstalować wszystkie Railsy i ich zależności za pomocą następującego polecenia z linii poleceń -

C:\> gem install rails

Note- Powyższe polecenie może zająć trochę czasu, aby zainstalować wszystkie zależności. Upewnij się, że masz połączenie z Internetem podczas instalowania zależności gems.

Krok 4: Sprawdź wersję Railsów

Użyj następującego polecenia, aby sprawdzić wersję szyn.

C:\> rails -v

Output

Rails 4.2.4

Gratulacje! Jesteś teraz na Railsach przez Windows.

Instalacja Railsów w systemie Linux

Instalujemy Ruby On Rails na Linuksie przy użyciu rbenv. Jest to lekkie narzędzie do zarządzania wersjami Rubiego. Plikrbenv zapewnia łatwą procedurę instalacji do zarządzania różnymi wersjami Ruby oraz solidne środowisko do tworzenia aplikacji Ruby on Rails.

Postępuj zgodnie z instrukcjami podanymi poniżej, aby zainstalować Ruby on Rails przy użyciu narzędzia rbenv.

Krok 1: Zainstaluj wstępnie wymagane zależności

Przede wszystkim musimy zainstalować git - corei kilka zależności od Rubiego, które pomagają zainstalować Ruby on Rails. Użyj następującego polecenia, aby zainstalować zależności Rails przy użyciuyum.

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

Krok 2: Zainstaluj rbenv

Teraz zainstalujemy rbenv i ustawimy odpowiednie zmienne środowiskowe. Użyj następującego zestawu poleceń, aby pobrać rbenv dla repozytorium 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

Krok 3: Zainstaluj Rubiego

Przed zainstalowaniem Rubiego określ, którą wersję Rubiego chcesz zainstalować. Zainstalujemy Ruby 2.2.3. Użyj następującego polecenia, aby zainstalować Rubiego.

tp> rbenv install -v 2.2.3

Użyj następującego polecenia, aby ustawić bieżącą wersję Ruby jako domyślną.

tp> rbenv global 2.2.3

Użyj następującego polecenia, aby sprawdzić wersję Rubiego.

tp> ruby -v

Output

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

Ruby udostępnia słowo kluczowe gemdo instalacji obsługiwanych zależności; nazywamy jegems. Jeśli nie chcesz instalować dokumentacji dla Ruby-gems, użyj następującego polecenia.

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

Później lepiej jest zainstalować narzędzie Bundler, ponieważ pomaga ono zarządzać zależnościami aplikacji. Użyj następującego polecenia, aby zainstalować pakiet Gem.

tp> gem install bundler

Krok 4: Zainstaluj Rails

Użyj następującego polecenia, aby zainstalować Rails w wersji 4.2.4.

tp> install rails -v 4.2.4

Użyj następującego polecenia, aby udostępnić plik wykonywalny Rails.

tp> rbenv rehash

Użyj następującego polecenia do sprawdzenia wersji szyn.

tp> rails -v

Output

tp> Rails 4.2.4

Framework Ruby on Rails wymaga JavaScript Runtime Environment (Node.js) do zarządzania funkcjami Railsów. Następnie zobaczymy, jak możemy użyć Node.js do zarządzania Asset Pipeline, który jest funkcją Railsów.

Krok 5: Zainstaluj JavaScript Runtime

Zainstalujmy Node.js z repozytorium Yum. Weźmiemy Node.js z repozytorium EPEL yum. Użyj następującego polecenia, aby dodać pakiet EPEL do repozytorium yum.

tp> sudo yum -y install epel-release

Użyj następującego polecenia, aby zainstalować pakiet Node.js.

tp> sudo yum install nodejs

Gratulacje! Jesteś teraz na Railsach przez Linuksa.

Krok 6: Zainstaluj bazę danych

Domyślnie Railsy używają sqlite3, ale możesz chcieć zainstalować MySQL, PostgreSQL lub inny RDBMS. To jest opcjonalne; jeśli masz zainstalowaną bazę danych, możesz pominąć ten krok i nie jest konieczne posiadanie zainstalowanej bazy danych do uruchomienia serwera railsowego. W tym samouczku używamy bazy danych PostgreSQL. Dlatego użyj następujących poleceń, aby zainstalować PostgreSQL.

tp> sudo yum install postgresql-server postgresql-contrib

Zaakceptuj monit, odpowiadając y. Użyj następującego polecenia, aby utworzyć klaster bazy danych PostgreSQl.

tp> sudo postgresql-setup initdb

Użyj następującego polecenia, aby uruchomić i włączyć PostgreSQL.

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

Aktualizowanie Railsów na bieżąco

Zakładając, że zainstalowałeś Railsy przy użyciu RubyGems, utrzymanie jego aktualności jest stosunkowo łatwe. Możemy użyć tego samego polecenia zarówno na platformie Windows, jak i Linux. Użyj następującego polecenia -

tp> gem update rails

Output

Poniższy zrzut ekranu przedstawia wiersz polecenia systemu Windows. Terminal Linux również zapewnia te same dane wyjściowe.

Spowoduje to automatyczną aktualizację instalacji Railsów. Następnym razem, gdy uruchomisz ponownie aplikację, wybierze ona najnowszą wersję Railsów. Korzystając z tego polecenia, upewnij się, że masz połączenie z Internetem.

Weryfikacja instalacji

Możesz sprawdzić, czy wszystko jest skonfigurowane zgodnie z Twoimi wymaganiami, czy nie. Użyj następującego polecenia, aby utworzyć projekt demonstracyjny.

tp> rails new demo

Output

Wygeneruje projekt kolei demonstracyjnej; omówimy to później. Obecnie musimy sprawdzić, czy środowisko jest skonfigurowane, czy nie. Następnie użyj następującego polecenia, aby uruchomić serwer WWW WEBrick na swoim komputerze.

tp> cd demo
tp> rails server

Wygeneruje automatyczny kod, aby uruchomić serwer

Teraz otwórz przeglądarkę i wpisz:

http://localhost:3000

Powinien wyświetlić komunikat, na przykład „Witamy na pokładzie” lub „Gratulacje”.

Framework to program, zestaw programów i / lub biblioteka kodu, która pisze dla Ciebie większość aplikacji. Kiedy używasz frameworka, Twoim zadaniem jest napisanie tych części aplikacji, które sprawią, że będzie ona wykonywała określone rzeczy, które chcesz.

Kiedy zaczynasz pisać aplikację Railsową, pomijając konfigurację i inne obowiązki porządkowe, musisz wykonać trzy podstawowe zadania -

Describe and model your application's domain- Domena to wszechświat Twojej aplikacji. Domeną może być sklep muzyczny, uniwersytet, serwis randkowy, książka adresowa lub spis sprzętu. Więc tutaj musisz dowiedzieć się, co w nim jest, jakie byty istnieją w tym wszechświecie i jak elementy w nim są powiązane ze sobą. Jest to równoważne z modelowaniem struktury bazy danych w celu zachowania jednostek i ich relacji.
Specify what can happen in this domain- Model domeny jest statyczny; musisz nadać mu dynamikę. Adresy można dodawać do książki adresowej. Partytury można kupić w sklepach muzycznych. Użytkownicy mogą zalogować się do serwisu randkowego. Studenci mogą zapisać się na zajęcia na uczelni. Musisz zidentyfikować wszystkie możliwe scenariusze lub akcje, w których mogą uczestniczyć elementy Twojej domeny.
Choose and design the publicly available views of the domain- W tym momencie możesz zacząć myśleć w kategoriach przeglądarki internetowej. Kiedy już zdecydujesz, że w Twojej domenie są studenci i że mogą oni rejestrować się na zajęcia, możesz wyobrazić sobie stronę powitalną, stronę rejestracji, stronę potwierdzenia itp. Każda z tych stron lub widoków pokazuje użytkownikowi, jak działa stanąć w pewnym momencie.

W oparciu o powyższe trzy zadania, Ruby on Rails zajmuje się strukturą Model / Widok / Kontroler (MVC).

Ruby on Rails MVC Framework

Plik Model View CZasada ontroller dzieli pracę aplikacji na trzy odrębne, ale ściśle współpracujące ze sobą podsystemy.

Model (ActiveRecord)

Utrzymuje relacje między obiektami a bazą danych i obsługuje walidację, skojarzenie, transakcje i nie tylko.

Ten podsystem jest zaimplementowany w bibliotece ActiveRecord, która zapewnia interfejs i powiązanie między tabelami w relacyjnej bazie danych i kodem programu Ruby, który manipuluje rekordami bazy danych. Nazwy metod Ruby są generowane automatycznie na podstawie nazw pól tabel bazy danych.

Widok (ActionView)

Jest to prezentacja danych w określonym formacie, wywołana decyzją administratora o przedstawieniu danych. Są to oparte na skryptach systemy szablonów, takie jak JSP, ASP, PHP i bardzo łatwe do zintegrowania z technologią AJAX.

Podsystem ten jest zaimplementowany w bibliotece ActionView, która jest systemem opartym na Embedded Ruby (ERb) do definiowania szablonów prezentacji do prezentacji danych. Każde połączenie internetowe z aplikacją Railsów powoduje wyświetlenie widoku.

Kontroler (ActionController)

Funkcja w aplikacji kierująca ruchem z jednej strony na odpytywanie modeli o określone dane, z drugiej organizowanie tych danych (wyszukiwanie, sortowanie, przesyłanie wiadomości) do postaci dopasowanej do potrzeb danego widoku.

Ten podsystem jest zaimplementowany w ActionController, który jest brokerem danych znajdującym się między ActiveRecord (interfejs bazy danych) a ActionView (silnik prezentacji).

Graficzne przedstawienie struktury MVC

Poniżej znajduje się obrazowe przedstawienie Ruby on Rails Framework -

Reprezentacja katalogu MVC Framework

Zakładając standardową, domyślną instalację w systemie Linux, można je znaleźć w ten sposób -

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

Zobaczysz podkatalogi, w tym (ale nie tylko) następujące -

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

W instalacji systemu Windows można je znaleźć w ten sposób -

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

Zobaczysz podkatalogi, w tym (ale nie tylko) następujące -

ActionView i ActionController są połączone razem w ActionPack.

ActiveRecord zapewnia szereg technik programowania i skrótów do manipulowania danymi z bazy danych SQL. ActionController i ActionView zapewniają narzędzia do manipulowania i wyświetlania tych danych. Szyny łączą to wszystko razem.

Kiedy używasz skryptu pomocniczego Rails do tworzenia aplikacji, tworzy on całą strukturę katalogów dla aplikacji. Railsy wiedzą, gdzie znaleźć potrzebne elementy w tej strukturze, więc nie musisz podawać żadnych danych wejściowych.

Oto widok najwyższego poziomu drzewa katalogów utworzonego przez skrypt pomocniczy w czasie tworzenia aplikacji. Z wyjątkiem drobnych zmian między wydaniami, każdy projekt Rails będzie miał taką samą strukturę, z tymi samymi konwencjami nazewnictwa. Ta konsekwencja daje ogromną przewagę; możesz szybko przemieszczać się między projektami Rails bez ponownego uczenia się organizacji projektu.

Aby zrozumieć tę strukturę katalogów, użyjmy demoaplikacja stworzona w rozdziale Instalacja. Można go utworzyć za pomocą prostego polecenia pomocnikarails demo.

Teraz przejdź do katalogu głównego aplikacji demonstracyjnej w następujący sposób -

tp> cd demo
demo> dir

Znajdziesz strukturę katalogów w systemie Windows w następujący sposób -

Teraz wyjaśnijmy cel każdego katalogu

app- Porządkuje komponenty aplikacji. Zawiera podkatalogi, które przechowują widok (widoki i pomoce), kontroler (kontrolery) i logikę biznesową zaplecza (modele).
app/controllers- Podkatalog controllers to miejsce, w którym Railsy szukają klas kontrolerów. Kontroler obsługuje żądanie internetowe od użytkownika.
app/helpers- Podkatalog helperów zawiera wszelkie klasy pomocnicze używane do wspomagania klas modelu, widoku i kontrolera. Pomaga to zachować mały, skoncentrowany i uporządkowany model, widok i kod kontrolera.
app/models- Podkatalog models zawiera klasy, które modelują i opakowują dane przechowywane w bazie danych naszej aplikacji. W większości frameworków ta część aplikacji może stać się dość niechlujna, żmudna, rozwlekła i podatna na błędy. Railsy sprawiają, że jest to banalnie proste!
app/view - Podkatalog views zawiera szablony wyświetlania do wypełnienia danymi z naszej aplikacji, konwersji do formatu HTML i powrotu do przeglądarki użytkownika.
app/view/layouts- Przechowuje pliki szablonów dla układów do użycia z widokami. To modeluje powszechną metodę zawijania widoków nagłówka / stopki. W swoich widokach zdefiniuj układ za pomocą <tt> layout: default </tt> i utwórz plik o nazwie default.html.erb. Wewnątrz default.html.erb wywołaj <% yield%>, aby wyrenderować widok przy użyciu tego układu.
components - Ten katalog zawiera komponenty, małe samodzielne aplikacje, które zawierają model, widok i kontroler.
config- Ten katalog zawiera niewielką ilość kodu konfiguracyjnego, którego będzie potrzebować aplikacja, w tym konfigurację bazy danych (w database.yml), strukturę środowiska Railsów (environment.rb) i routing przychodzących żądań internetowych (route.rb). Możesz także dostosować zachowanie trzech środowisk Railsowych do testowania, programowania i wdrażania za pomocą plików znajdujących się w katalogu environment.
db- Zazwyczaj Twoja aplikacja Railsowa będzie miała obiekty modelu, które mają dostęp do tabel relacyjnej bazy danych. Możesz zarządzać relacyjną bazą danych za pomocą skryptów, które tworzysz i umieszczasz w tym katalogu.
doc- Ruby ma strukturę zwaną RubyDoc, która może automatycznie generować dokumentację dla tworzonego kodu. Możesz pomóc RubyDoc w komentarzach w swoim kodzie. Ten katalog zawiera wszystkie Railsy wygenerowane przez RubyDoc i dokumentację aplikacji.
lib - Tutaj umieścisz biblioteki, chyba że wyraźnie należą one gdzie indziej (na przykład biblioteki dostawców).
log- Tutaj znajdują się dzienniki błędów. Railsy tworzą skrypty, które pomagają w zarządzaniu różnymi dziennikami błędów. Znajdziesz osobne dzienniki dla serwera (server.log) i każdego środowiska Rails (development.log, test.log i production.log).
public - Podobnie jak katalog publiczny serwera WWW, katalog ten zawiera pliki internetowe, które się nie zmieniają, takie jak pliki JavaScript (public / javascripts), grafiki (public / images), arkusze stylów (public / stylesheets) i pliki HTML (public ).
script- Ten katalog zawiera skrypty do uruchamiania i zarządzania różnymi narzędziami, których będziesz używać z Railsami. Na przykład istnieją skrypty do generowania kodu (generowania) i uruchamiania serwera WWW (serwera).
test- Testy, które piszesz i te, które tworzy dla Ciebie Rails, znajdują się tutaj. Zobaczysz podkatalog dla makiet (mocków), testów jednostkowych (jednostkowych), urządzeń (urządzeń) i testów funkcjonalnych (funkcjonalnych).
tmp - Railsy używają tego katalogu do przechowywania plików tymczasowych do pośredniego przetwarzania.
vendor - Biblioteki dostarczane przez zewnętrznych dostawców (takie jak biblioteki bezpieczeństwa lub narzędzia bazodanowe poza podstawową dystrybucją Rails) znajdują się tutaj.

Oprócz tych katalogów w katalogu demo będą dostępne dwa pliki.

README - Ten plik zawiera podstawowe szczegóły dotyczące aplikacji kolejowej i opis struktury katalogów wyjaśnionej powyżej.
Rakefile- Ten plik jest podobny do Unix Makefile, który pomaga w budowaniu, pakowaniu i testowaniu kodu Railsów. Będzie to używane przez narzędzie rake dostarczane wraz z instalacją Rubiego.

W tym rozdziale stworzymy prosty, ale działający system biblioteczny online do przechowywania i zarządzania książkami.

Ta aplikacja ma podstawową architekturę i zostanie zbudowana przy użyciu dwóch modeli ActiveRecord do opisywania typów przechowywanych danych -

Książki, które opisują rzeczywisty wykaz.
Temat, który służy do grupowania książek.

Proces tworzenia aplikacji Railsowych

Zalecany przepływ pracy przy tworzeniu aplikacji Rails jest następujący -

Użyj polecenia rails, aby utworzyć podstawowy szkielet aplikacji.
Utwórz bazę danych na serwerze PostgreSQL, aby przechowywać swoje dane.
Skonfiguruj aplikację, aby wiedziała, gdzie znajduje się Twoja baza danych i jakie dane logowania do niej są.
Utwórz aktywne rekordy (modele) Rails, ponieważ są to obiekty biznesowe, z którymi będziesz pracować w kontrolerach.
Generuj migracje, które upraszczają tworzenie i obsługę tabel i kolumn bazy danych.
Napisz kod kontrolera, aby ożywić swoją aplikację.
Utwórz widoki, aby przedstawić swoje dane za pośrednictwem interfejsu użytkownika.

Zacznijmy więc od stworzenia naszej aplikacji bibliotecznej.

Tworzenie pustej aplikacji internetowej Rails

Railsy to zarówno środowisko uruchomieniowe aplikacji internetowych, jak i zestaw skryptów pomocniczych, które automatyzują wiele czynności wykonywanych podczas tworzenia aplikacji internetowych. W tym kroku użyjemy jednego takiego skryptu pomocniczego do stworzenia całej struktury katalogów i początkowego zestawu plików, aby uruchomić naszą aplikację Library System.

Przejdź do katalogu instalacyjnego Ruby, aby utworzyć aplikację.
Uruchom następujące polecenie, aby utworzyć szkielet aplikacji bibliotecznej. Stworzy strukturę katalogów w bieżącym katalogu.

tp> rails new library

Spowoduje to utworzenie podkatalogu dla aplikacji biblioteki, zawierającego pełne drzewo katalogów folderów i plików dla pustej aplikacji Railsowej. Sprawdź pełną strukturę katalogów aplikacji. Sprawdź strukturę katalogów Rails, aby uzyskać więcej szczegółów.

Większość naszej pracy programistycznej będzie polegała na tworzeniu i edytowaniu plików w formacie library/apppodkatalogach. Oto krótkie omówienie, jak ich używać -

Kontrolery podkatalogu gdzie Szyny spojrzenia znaleźć sterownika klas. Kontroler obsługuje żądanie internetowe od użytkownika.
W podkatalogu views znajdują się szablony wyświetlania służące do wypełnienia danymi z naszej aplikacji, konwersji do formatu HTML i powrotu do przeglądarki użytkownika.
W podkatalogu models znajdują się klasy, które modelują i zawijają dane przechowywane w bazie danych naszej aplikacji. W większości frameworków ta część aplikacji może być dość niechlujna, żmudna, rozwlekła i podatna na błędy. Dzięki Railsom jest to banalnie proste.
Pomocnicy podkatalogu posiada żadnych klas pomocniczych wykorzystywanych do wspomagania klasy model, widok i kontroler. Pomaga to zachować mały, skoncentrowany i uporządkowany model, widok i kod kontrolera.

Uruchamianie serwera WWW

Aplikacja internetowa Rails może działać praktycznie na każdym serwerze WWW, ale najwygodniejszym sposobem tworzenia aplikacji internetowej Rails jest użycie wbudowanego serwera WWW WEBrick. Uruchommy ten serwer WWW, a następnie przejdźmy do naszej pustej aplikacji bibliotecznej -

Ten serwer zostanie uruchomiony z katalogu aplikacji w następujący sposób. Działa na porcie numer 3000.

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

Generuje automatyczny kod do uruchomienia serwera, jak pokazano poniżej -

Spowoduje to uruchomienie serwera WWW WEBrick.

Teraz otwórz przeglądarkę i przejdź do http://127.0.0.1:3000. Jeśli wszystko poszło dobrze, powinieneś zobaczyć powitanie od WEBrick, w przeciwnym razie coś jest nie tak z ustawieniami. Jeśli wszystko pójdzie dobrze, wygeneruje wynik w następujący sposób.

Co jest następne?

Następny rozdział wyjaśnia, jak tworzyć bazy danych dla twojej aplikacji i jaka jest konfiguracja wymagana do uzyskania dostępu do tych utworzonych baz danych.

Dalej zobaczymy, czym jest migracja Railsów i jak jest używana do utrzymywania tabel bazy danych.

Zanim zaczniesz od tego rozdziału, upewnij się, że serwer bazy danych jest uruchomiony i działa. Ruby on Rails zaleca utworzenie trzech baz danych - po jednej dla środowiska programistycznego, testowego i produkcyjnego. Zgodnie z konwencją ich imiona powinny brzmieć -

library_development
library_production
library_test

Powinieneś zainicjować wszystkie trzy z nich i utworzyć dla nich użytkownika i hasło z pełnymi uprawnieniami do odczytu i zapisu. Używamyroot identyfikator użytkownika dla naszej aplikacji.

Konfiguracja bazy danych dla MySQL

W MySQL używamy rozszerzenia rootidentyfikator użytkownika dla naszej aplikacji. Sesja konsoli MySQL, w której to robisz, wygląda mniej więcej tak:

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)

Możesz zrobić to samo dla dwóch kolejnych baz danych library_production i library_test.

Konfigurowanie database.yml

W tym momencie musisz poinformować Railsy o nazwie użytkownika i haśle do baz danych. Robisz to w plikudatabase.yml, dostępne w library\configw podkatalogu aplikacji Rails, którą utworzyłeś. Ten plik zawiera sekcje konfiguracji na żywo dla baz danych MySQL. W każdej z sekcji, których używasz, musisz zmienić linię nazwy użytkownika i hasła, aby odzwierciedlić uprawnienia w utworzonych bazach danych.

Kiedy skończysz, powinno wyglądać mniej więcej tak -

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

Konfiguracja bazy danych dla PostgreSQL

Domyślnie PostgreSQL nie udostępnia żadnych użytkowników. Musimy stworzyć nowych użytkowników. Użyj następującego polecenia, aby utworzyć użytkownika o tej nazwierubyuser.

tp> sudo -u postgres createuser rubyuser -s

Jeśli chcesz utworzyć hasło dla nowego użytkownika, użyj następującego polecenia.

tp> sudo -u postgres psql

postgres=# \password rubyuser

Użyj następującego polecenia, aby utworzyć bazę danych library_development.

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

Użyj następującego polecenia, aby utworzyć bazę danych library_production.

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

Użyj następującego polecenia, aby utworzyć bazę danych library_test.

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

naciśnij Ctrl+D aby zakończyć PosgreSQL.

Konfigurowanie database.yml

W tym momencie musisz podać Railsom nazwę użytkownika i hasło do baz danych. Robisz to w plikudatabase.yml, dostępne w library\configw podkatalogu aplikacji Rails, którą utworzyłeś. Ten plik zawiera sekcje konfiguracji na żywo dla baz danych PostgreSQL. W każdej sekcji musisz zmienić linię nazwy użytkownika i hasła, aby odzwierciedlić uprawnienia w utworzonych bazach danych.

Kiedy skończysz, powinno wyglądać następująco -

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>

Co jest następne?

Kolejne dwa rozdziały wyjaśniają, jak modelować tabele bazy danych i jak zarządzać nimi za pomocą migracji Rails.

Rails Active Record to warstwa Object / Relational Mapping (ORM) dostarczana z Railsami. Jest ściśle zgodny ze standardowym modelem ORM, który przedstawia się następująco -

tabele odwzorowują klasy,
wiersze są mapowane na obiekty i
kolumny są mapowane na atrybuty obiektu.

Rails Active Records zapewniają interfejs i powiązanie między tabelami w relacyjnej bazie danych a kodem programu Ruby, który manipuluje rekordami bazy danych. Nazwy metod Ruby są generowane automatycznie na podstawie nazw pól tabel bazy danych.

Każdy obiekt Active Record ma CRUD (CReate, Read, Update i Delete) metody dostępu do bazy danych. Ta strategia umożliwia tworzenie prostych projektów i bezpośrednie mapowanie między tabelami bazy danych i obiektami aplikacji.

Tłumaczenie modelu domeny na język SQL

Tłumaczenie modelu domeny na SQL jest generalnie proste, o ile pamiętasz, że musisz pisać SQL przyjazny dla Railsów. W praktyce musisz przestrzegać pewnych zasad -

Każda jednostka (taka jak książka) otrzymuje w bazie danych tabelę nazwaną na jej cześć, ale w liczbie mnogiej (książki).
Każda taka tabela dopasowywania jednostek ma pole o nazwie id , które zawiera unikalną liczbę całkowitą dla każdego rekordu wstawionego do tabeli.
Dana jednostka x i jednostka y, jeśli jednostka y należy do jednostki x, to tabela y ma pole o nazwie x_id.
Większość pól w dowolnej tabeli przechowuje wartości prostych właściwości tej jednostki (wszystko, co jest liczbą lub ciągiem).

Tworzenie plików Active Record (modeli)

Aby stworzyć pliki Active Record dla naszych encji dla aplikacji bibliotecznej, przedstawione w poprzednim rozdziale, należy wydać następujące polecenie z najwyższego poziomu katalogu aplikacji.

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

Powyżej rails generate model book polecenia generują kod automatyczny, jak poniżej -

Mówisz generatorowi, aby utworzył modele o nazwie Książka i Temat do przechowywania wystąpień książek i przedmiotów. Zwróć uwagę, że wpisujesz książkę i temat wielkimi literami i używasz liczby pojedynczej. To jest paradygmat Rails, którego powinieneś przestrzegać za każdym razem, gdy tworzysz model.

Kiedy używasz narzędzia do generowania, Rails tworzy rzeczywisty plik modelu, który zawiera wszystkie metody unikalne dla modelu i zdefiniowanych reguł biznesowych, plik testów jednostkowych do wykonywania programowania sterowanego testami, przykładowy plik danych (zwany fixtures) do użycia z testami jednostkowymi i migracją Railsów, która ułatwia tworzenie tabel i kolumn bazy danych.

Oprócz tworzenia wielu innych plików i katalogów, spowoduje to utworzenie plików o nazwie book.rb i subject.rb zawierający definicję szkieletu w app/models informator.

Treść dostępna w book.rb -

class Book < ActiveRecord::Base
end

Treść dostępna w subject.rb -

class Subject < ActiveRecord::Base
end

Tworzenie skojarzeń między modelami

Jeśli masz więcej niż jeden model w swojej aplikacji szynowej, musisz utworzyć połączenie między tymi modelami. Możesz to zrobić za pośrednictwem skojarzeń. Active Record obsługuje trzy typy asocjacji -

one-to-one- Relacja jeden do jednego występuje, gdy jeden element ma dokładnie jeden inny element. Na przykład osoba ma dokładnie jedno urodziny lub pies ma dokładnie jednego właściciela.
one-to-many- Relacja jeden do wielu występuje, gdy pojedynczy obiekt może być członkiem wielu innych obiektów. Na przykład jeden przedmiot może mieć wiele książek.
many-to-many - Relacja wiele do wielu występuje, gdy pierwszy obiekt jest powiązany z co najmniej jednym drugim obiektem, a drugi obiekt jest powiązany z jednym lub wieloma pierwszymi obiektami.

Wskazujesz te powiązania, dodając deklaracje do swoich modeli: has_one, has_many, contrib_to i has_and_belongs_to_many.

Teraz musisz powiedzieć Railsom, jakie relacje chcesz ustanowić w systemie danych biblioteki. Aby to zrobić, zmodyfikuj book.rb i subject.rb, aby wyglądały następująco -

class Book < ActiveRecord::Base
   belongs_to :subject
end

W powyższym przykładzie użyliśmy pojedynczego przedmiotu, ponieważ jedna książka może należeć do jednego przedmiotu.

class Subject < ActiveRecord::Base
   has_many :books
end

Użyliśmy tutaj liczby mnogiej, ponieważ jeden przedmiot może mieć wiele książek.

Wdrażanie walidacji w modelach

Implementacja walidacji odbywa się w modelu Railsowym. Dane, które wprowadzasz do bazy danych, są zdefiniowane w rzeczywistym modelu Rails, więc sensowne jest tylko zdefiniowanie, jakie prawidłowe dane dotyczą tej samej lokalizacji.

Walidacje są -

Wartość pola tytułu nie powinna wynosić NULL.
Wartość pola ceny powinna być liczbowa.

otwarty book.rb w app\model subdiractory i umieścić następujące walidacje -

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

validates_presence_of - chroni pola „NOT NULL” przed brakiem danych wejściowych użytkownika.
validates_numericality_of - zapobiega wprowadzaniu przez użytkownika danych nienumerycznych.

Oprócz walidacji wymienionych powyżej istnieją inne powszechne walidacje. Sprawdź Szybki przewodnik po Railsach .

Co jest następne?

W następnym rozdziale nauczymy się migracji Railsów, która pozwala używać Rubiego do definiowania zmian w schemacie bazy danych, umożliwiając użycie systemu kontroli wersji do synchronizacji rzeczy z rzeczywistym kodem.

Migracja Railsów pozwala na użycie Rubiego do definiowania zmian w schemacie bazy danych, umożliwiając użycie systemu kontroli wersji do synchronizacji rzeczy z rzeczywistym kodem.

Ma to wiele zastosowań, w tym -

Teams of developers - Jeśli jedna osoba zmieni schemat, pozostali programiści muszą tylko zaktualizować i uruchomić „migrację rake”.
Production servers - Uruchom „rake migrate”, gdy wprowadzasz nową wersję, aby zaktualizować bazę danych.
Multiple machines - Jeśli programujesz zarówno na komputerze stacjonarnym, jak i laptopie lub w więcej niż jednej lokalizacji, migracje mogą pomóc w ich synchronizacji.

Co może zrobić migracja Railsów?

create_table (nazwa, opcje)
drop_table(name)
rename_table (stara_nazwa, nowa_nazwa)
add_column (nazwa_tabeli, nazwa_kolumny, typ, opcje)
rename_column (nazwa_tabeli, nazwa_kolumny, nazwa_nowej_kolumny)
zmiana_kolumny (nazwa_tabeli, nazwa_kolumny, typ, opcje)
remove_column (nazwa_tabeli, nazwa_kolumny)
add_index (nazwa_tabeli, nazwa_kolumny, typ_indeksu)
remove_index (nazwa_tabeli, nazwa_kolumny)

Migrations support all the basic data types - Poniżej znajduje się lista typów danych obsługiwanych przez migrację -

string - dla małych typów danych, takich jak tytuł.
text - w przypadku dłuższych fragmentów danych tekstowych, takich jak opis.
integer - dla liczb całkowitych.
float - dla liczb dziesiętnych.
datetime and timestamp - zapisz datę i godzinę w kolumnie.
date and time - przechowywać tylko datę lub tylko godzinę.
binary - do przechowywania danych, takich jak obrazy, dźwięk lub filmy.
Boolean - do przechowywania wartości prawda lub fałsz.

Valid column options are - Poniżej znajduje się lista prawidłowych opcji kolumn.

limit (: limit => „50”)
default (: default => „bla”)
null(: null => false oznacza NIE NULL )

NOTE - Czynności wykonywane przez Rails Migration mogą być wykonywane przy użyciu dowolnego front-endowego GUI lub bezpośrednio z podpowiedzi SQL, ale Rails Migration sprawia, że wszystkie te czynności są bardzo łatwe.

Więcej informacji na ten temat znajdziesz w Rails API .

Utwórz migracje

Oto ogólna składnia tworzenia migracji -

application_dir> rails generate migration table_name

Spowoduje to utworzenie pliku db / migrate / 001_table_name.rb. Plik migracji zawiera podstawową składnię Ruby, która opisuje strukturę danych tabeli bazy danych.

NOTE - Przed uruchomieniem generatora migracji zaleca się wyczyszczenie istniejących migracji wygenerowanych przez generatory modeli.

Stworzymy dwie migracje odpowiadające naszym trzem tabelom - books and subjects.

Migracja książek powinna wyglądać następująco -

tp> cd library
library> rails generate migration books

Powyższe polecenie generuje następujący kod.

migracja podmiotów powinna wyglądać następująco -

tp> cd library
library> rails generate migration subjects

Powyższe polecenie generuje następujący kod.

Zwróć uwagę, że podczas tworzenia migracji używasz małych liter dla książki i tematu oraz liczby mnogiej. Jest to paradygmat Rails, którego powinieneś przestrzegać za każdym razem, gdy tworzysz migrację.

Edytuj kod

Przejdź do podkatalogu db / migrate swojej aplikacji i edytuj każdy plik jeden po drugim, używając dowolnego prostego edytora tekstu.

Zmodyfikuj 001_books.rb w następujący sposób -

Kolumna ID zostanie utworzona automatycznie, więc nie rób tego również tutaj.

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

Metoda self.up jest używany podczas migracji do nowej wersji, self.downsłuży do cofania wszelkich zmian w razie potrzeby. W tym momencie powyższy skrypt zostanie wykorzystany do stworzeniabooks stół.

Zmodyfikuj 002_subjects.rb w następujący sposób -

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

Powyższy skrypt zostanie użyty do stworzenia subjects table i utworzy pięć rekordów w tabeli przedmiotów.

Uruchom migrację

Teraz, gdy utworzyłeś wszystkie wymagane pliki migracji. Nadszedł czas, aby wykonać je w bazie danych. Aby to zrobić, przejdź do wiersza poleceń i przejdź do katalogu biblioteki, w którym znajduje się aplikacja, a następnie wpiszrake migrate w następujący sposób -

library> rake db:migrate

Spowoduje to utworzenie tabeli „schema_info”, jeśli nie istnieje, która śledzi aktualną wersję bazy danych - każda nowa migracja będzie nową wersją, a wszystkie nowe migracje będą uruchamiane, dopóki baza danych nie będzie w aktualnej wersji.

RakeRuby jest podobna do budowy programu Unix make program, który korzysta z Rails, aby uprościć wykonywanie złożonych zadań, takich jak aktualizowanie struktury danej bazie danych za etc.

Uruchamianie migracji produkcyjnych i testowych baz danych

Jeśli chcesz określić, jakiego środowiska Railsów użyć do migracji, użyj zmiennej powłoki RAILS_ENV.

Na przykład -

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- W systemie Windows użyj polecenia „set RAILS_ENV = production” zamiast polecenia eksportu .

Co jest następne?

Teraz mamy dostępną naszą bazę danych i wymagane tabele. W dwóch kolejnych rozdziałach zbadamy dwa ważne komponenty o nazwie Controller (ActionController) i View (ActionView).

Tworzenie kontrolerów (kontroler akcji).
Tworzenie widoków (widok akcji).

Kontroler Rails jest logicznym centrum twojej aplikacji. Koordynuje interakcję między użytkownikiem, widokami i modelem. Kontroler jest również domem dla wielu ważnych usług pomocniczych.

Odpowiada za kierowanie żądań zewnętrznych do akcji wewnętrznych. Bardzo dobrze obsługuje przyjazne dla ludzi adresy URL.
Zarządza buforowaniem, co może zwiększyć wydajność aplikacji o rzędy wielkości.
Zarządza modułami pomocniczymi, które rozszerzają możliwości szablonów widoków bez łączenia ich kodu.
Zarządza sesjami, dając użytkownikom wrażenie ciągłej interakcji z naszymi aplikacjami.

Proces tworzenia kontrolera jest bardzo łatwy i podobny do procesu, którego już używaliśmy do tworzenia modelu. Stworzymy tutaj tylko jeden kontroler -

library\> rails generate controller Book

Zwróć uwagę, że zapisujesz książkę wielką literą i używasz liczby pojedynczej. To jest paradygmat Rails, którego powinieneś przestrzegać za każdym razem, gdy tworzysz kontroler.

To polecenie wykonuje kilka zadań, z których poniższe mają znaczenie:

Tworzy plik o nazwie app/controllers/book_controller.rb

Jeśli spojrzysz na book_controller.rb, znajdziesz go w następujący sposób -

class BookController < ApplicationController
end

Klasy kontrolerów dziedziczą po ApplicationController, czyli drugim pliku w folderze controllers:application.rb.

ApplicationController zawiera kod, który można uruchomić we wszystkich kontrolerach i dziedziczy z Rails ActionController :: Base klasy.

Na razie nie musisz się martwić o ApplicationController , więc po prostu zdefiniujmy kilka kodów pośredniczących metod wbook_controller.rb. W zależności od wymagań możesz zdefiniować dowolną liczbę funkcji w tym pliku.

Zmodyfikuj plik tak, aby wyglądał jak poniżej i zapisz zmiany. Pamiętaj, że to od Ciebie zależy, jaką nazwę chcesz nadać tym metodom, ale lepiej nadaj im odpowiednie nazwy.

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

Teraz zaimplementujmy kolejno wszystkie metody.

Implementacja metody listy

Metoda list wyświetla listę wszystkich książek w bazie danych. Ta funkcjonalność zostanie osiągnięta przez następujące wiersze kodu. Edytuj następujące wiersze w pliku book_controller.rb.

def list
   @books = Book.all
end

Linia @books = Book.all w metodzie list mówi Railsom, aby przeszukał tabelę książek i zapisał każdy znaleziony wiersz w obiekcie instancji @books.

Wdrażanie metody pokazowej

Metoda show wyświetla tylko dalsze szczegóły dotyczące jednej książki. Ta funkcjonalność zostanie osiągnięta przez następujące wiersze kodu.

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

Linia @book = Book.find (params [: id]) metody show nakazuje Railsom znalezienie tylko tej książki, która ma identyfikator zdefiniowany w params [: id].

Obiekt params jest kontenerem, który umożliwia przekazywanie wartości między wywołaniami metod. Na przykład, gdy jesteś na stronie wywołanej metodą list, możesz kliknąć łącze do określonej książki, która przekazuje identyfikator tej książki za pośrednictwem obiektu params, aby program mógł znaleźć określoną książkę.

Wdrażanie nowej metody

Nowa metoda pozwala Railsom wiedzieć, że utworzysz nowy obiekt. Więc po prostu dodaj następujący kod w tej metodzie.

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

Powyższa metoda zostanie wywołana, gdy wyświetlisz użytkownikowi stronę, na której można wprowadzić dane wejściowe. Tutaj druga linia pobiera wszystkie tematy z bazy danych i umieszcza je w tablicy o nazwie @subjects.

Implementacja metody create

Po wprowadzeniu danych przez użytkownika za pomocą formularza HTML nadszedł czas, aby utworzyć rekord w bazie danych. Aby to osiągnąć, edytuj metodę create w book_controller.rb, tak aby pasowała do następującego -

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

Pierwsza linia tworzy nową zmienną instancji o nazwie @book, która zawiera obiekt Book zbudowany na podstawie danych przesłanych przez użytkownika. Plikbook_params Metoda służy do zbierania wszystkich pól z obiektu :books. Dane zostały przekazane z nowej metody do utworzenia przy użyciu obiektu params.

Następna linia to instrukcja warunkowa, która przekierowuje użytkownika do listmetoda, jeśli obiekt zapisuje się poprawnie w bazie danych. Jeśli nie zapisze, użytkownik zostanie odesłany z powrotem do nowej metody. Metoda redirect_to jest podobna do wykonywania metaodświeżania na stronie internetowej: automatycznie przekierowuje Cię do miejsca docelowego bez interakcji z użytkownikiem.

Wtedy @subjects = Subject.all jest wymagane na wypadek, gdyby dane nie zostały pomyślnie zapisane i sytuacja wygląda podobnie jak w przypadku nowej opcji.

Implementacja metody edycji

Metoda edit wygląda prawie identycznie jak metoda show. Obie metody służą do pobrania pojedynczego obiektu na podstawie jego identyfikatora i wyświetlenia go na stronie. Jedyna różnica polega na tym, że metody show nie można edytować.

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

Ta metoda zostanie wywołana w celu wyświetlenia danych na ekranie do zmodyfikowania przez użytkownika. Druga linia pobiera wszystkie tematy z bazy danych i umieszcza je w tablicy o nazwie @subjects.

Implementacja metody aktualizacji

Ta metoda zostanie wywołana po metodzie edit, gdy użytkownik modyfikuje dane i chce zaktualizować zmiany w bazie danych. Metoda aktualizacji jest podobna do metody tworzenia i będzie używana do aktualizacji istniejących książek w bazie danych.

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

Metoda update_attributes jest podobna do metody zapisu używanej przez create, ale zamiast tworzyć nowy wiersz w bazie danych, zastępuje atrybuty istniejącego wiersza.

Następnie wiersz @subjects = Subject.all jest wymagany na wypadek, gdyby dane nie zostały pomyślnie zapisane, wtedy staje się podobny do opcji edycji.

Implementacja metody usuwania

Jeśli chcesz usunąć rekord z bazy danych, użyjesz tej metody. Zaimplementuj tę metodę w następujący sposób.

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

Pierwsza linia wyszukuje klasyfikację na podstawie parametru przekazanego przez obiekt params, a następnie usuwa ją metodą zniszczenia. Druga linia przekierowuje użytkownika do metody list przy użyciu wywołania redirect_to.

Dodatkowe metody wyświetlania tematów

Załóżmy, że chcesz udostępnić użytkownikom możliwość przeglądania wszystkich książek na dany temat. Możesz więc utworzyć metodę wewnątrz book_controller.rb, aby wyświetlić wszystkie tematy. Załóżmy, że nazwa metody toshow_subjects -

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

Wreszcie twój book_controller.rb plik będzie wyglądał następująco -

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

Teraz zapisz plik kontrolera.

Co jest następne?

Stworzyłeś prawie wszystkie metody, które będą działać na zapleczu. Następnie zdefiniujemy trasy (adresy URL) dla akcji.

Moduł routingu zapewnia przepisywanie adresów URL w natywnym języku Ruby. Jest to sposób na przekierowanie przychodzących żądań do kontrolerów i akcji. Zastępuje reguły mod_rewrite. Co najlepsze, routing Railsów działa z każdym serwerem WWW. Trasy są zdefiniowane w app / config / tours.rb.

Pomyśl o tworzeniu tras jak o rysowaniu mapy dla swoich żądań. Mapa mówi im, dokąd mają iść, na podstawie określonego wcześniej wzoru -

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

Przykład

Rozważmy, że nasza aplikacja do zarządzania biblioteką zawiera kontroler o nazwie BookController. Musimy zdefiniować trasy dla tych akcji, które są zdefiniowane jako metody w klasie BookController.

Otwórz plik route.rb w katalogu library / config / i edytuj go z następującą zawartością.

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

Plik tours.rb definiuje akcje dostępne w aplikacjach oraz typ akcji, na przykład pobieranie, wysyłanie i łatanie.

Użyj następującego polecenia, aby wyświetlić listę wszystkich zdefiniowanych tras, które są przydatne do śledzenia problemów z routingiem w aplikacji lub zapewniają dobry przegląd adresów URL w aplikacji, z którą próbujesz się zapoznać.

library> rake routes

Co jest następne?

Następnie utworzymy kod do generowania ekranów do wyświetlania danych i pobierania danych wejściowych od użytkownika.

Widok Railsów to program ERb, który udostępnia dane kontrolerom poprzez wzajemnie dostępne zmienne.

Jeśli zajrzysz do katalogu app / views aplikacji bibliotecznej, zobaczysz po jednym podkatalogu dla każdego z utworzonych przez nas kontrolerów: książka. Każdy z tych podkatalogów został utworzony automatycznie, gdy kontroler o tej samej nazwie został utworzony za pomocą skryptu generującego.

Railsy informują Cię, że musisz utworzyć plik widoku dla każdej nowej metody. Każda metoda zdefiniowana w kontrolerze musi mieć odpowiedni plikerb plik o tej samej nazwie co metoda, aby wyświetlić dane zbierane przez metodę.

Stwórzmy więc pliki widoku dla wszystkich metod, które zdefiniowaliśmy w book_controller.rb. Podczas wykonywania tych widoków jednocześnie sprawdź, czy te akcje mają zastosowanie w bazie danych, czy nie.

Tworzenie pliku widoku dla metody listy

Utwórz plik o nazwie list.html.erbużywając swojego ulubionego edytora tekstu i zapisz go w app / views / book. Po utworzeniu i zapisaniu pliku odśwież przeglądarkę internetową. Powinieneś zobaczyć pustą stronę; jeśli nie, sprawdź pisownię swojego pliku i upewnij się, że jest dokładnie taka sama, jak metoda Twojego kontrolera.

Teraz wyświetl rzeczywistą zawartość. Umieśćmy następujący kod w 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>

Kod do wykonania ma na celu sprawdzenie, czy tablica @books zawiera jakieś obiekty. Plik.blank?metoda zwraca true, jeśli tablica jest pusta, lub false, jeśli zawiera jakiekolwiek obiekty. Ten obiekt @books został utworzony w kontrolerze wewnątrz metody list.

Kod między tagami <% =%> to link_towywołanie metody. Pierwszym parametrem link_to jest tekst, który ma być wyświetlany między tagami <a>. Drugi parametr to akcja wywoływana po kliknięciu łącza. W tym przypadku jest to metoda pokazu. Ostatnim parametrem jest identyfikator książki, która jest przekazywana przez obiekt params.

Teraz spróbuj odświeżyć przeglądarkę, a powinieneś zobaczyć następujący ekran, ponieważ nie mamy żadnej książki w naszej bibliotece.

Tworzenie pliku widoku dla nowej metody

Do tej pory nie mamy żadnej książki w naszej bibliotece. Musimy stworzyć kilka książek w systemie. Zatem zaprojektujmy widok odpowiadającynew metoda zdefiniowana w book_controller.rb.

Utwórz plik o nazwie new.html.erb za pomocą swojego ulubionego edytora tekstu i zapisz go w app / views / book. Dodaj następujący kod do pliku 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'} %>

Tutaj form_taginterpretuje kod Ruby na zwykły znacznik HTML <form> przy użyciu wszystkich dostarczonych informacji. Na przykład ten tag generuje następujący kod HTML -

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

Następna metoda to text_fieldktóre wyświetla pole tekstowe <input>. Parametry pola tekstowego to nazwa obiektu i pola. W tym przypadku obiektem jest książka, a nazwa to tytuł .

Metoda Railsów o nazwie collection_select, tworzy menu wyboru HTML zbudowane z tablicy, takiej jak @books. Istnieje pięć parametrów, które są następujące:

:book - Obiekt, którym manipulujesz. W tym przypadku jest to książka.
:subject_id - Pole, które jest zapełniane podczas zapisywania książki.
@books - Tablica, z którą pracujesz.
:id- wartość przechowywana w bazie danych. W przypadku HTML jest to parametr wartości tagu <option>.
:name- dane wyjściowe, które użytkownik widzi w menu rozwijanym. To jest wartość między tagami <option>.

Następnym używanym jest submit_tag, co generuje przycisk <input>, który przesyła formularz. Wreszcie jestend metoda, która po prostu tłumaczy się na </form>.

Przejdź do przeglądarki i odwiedź http://localhost:3000/book/new. Spowoduje to wyświetlenie następującego ekranu.

Wprowadź dane w tym formularzu, a następnie kliknij przycisk Utwórz. Tutaj dodałem następujące szczegóły do pól -

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

Po kliknięciu Create przycisk, wywoła create metoda, która nie wymaga żadnego widoku, ponieważ ta metoda używa jednego z nich list lub newmetody przeglądania wyników. Po kliknięciu przycisku Utwórz dane powinny zostać pomyślnie przesłane i przekierować do strony listy, na której znajduje się teraz jeden element wymieniony w następujący sposób -

Jeśli klikniesz link, powinieneś zobaczyć kolejny błąd Brak szablonu, ponieważ nie utworzyłeś jeszcze pliku szablonu dla metody show.

Tworzenie pliku widoku dla metody pokazu

Ta metoda wyświetli wszystkie szczegóły dotyczące każdej książki dostępnej w bibliotece. Utwórz plik show.html.erb w sekcji app / views / book i wypełnij go następującym kodem -

<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'} %>

To pierwszy raz, kiedy w pełni wykorzystujesz asocjacje, które umożliwiają łatwe pobieranie danych z powiązanych obiektów.

Używany format to @variable.relatedObject.column. W tym przypadku możesz przeciągnąć wartość nazwy podmiotu przez zmienną @book przy użyciubelongs_towspomnienia. Kliknięcie dowolnego wpisu na liście spowoduje wyświetlenie następującego ekranu.

Tworzenie pliku widoku do edycji

Utwórz nowy plik o nazwie edit.html.erb i zapisz go w app / views / book. Wypełnij go następującym kodem -

<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' } %>

Ten kod jest bardzo podobny do new metoda z wyjątkiem akcji do zaktualizowania zamiast tworzenia i definiowania id.

W tym scenariuszu użyliśmy form_fortag dla akcji formularza. Będzie działać lepiej niżform_tag. Dlaczego, ponieważ łatwo stworzy interakcję z modelem. Dlatego lepiej jest używać tagu form_for, gdy potrzebujesz interakcji między modelem a polami formularza.

W tym momencie potrzebujemy pewnych modyfikacji w list method'szobaczyć plik. Przejdź do elementu <li> </li> i zmodyfikuj go, aby wyglądał następująco -

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

Teraz spróbuj przeglądać książki za pomocą rozszerzenia http://localhost:3000/book/list. To daje listę wszystkich książek wraz z Editopcja. Po kliknięciu opcji Edytuj pojawi się następny ekran w następujący sposób -

Teraz edytuj te informacje, a następnie kliknij przycisk Zapisz zmiany . Spowoduje to wezwanie doupdatemetody dostępnej w pliku kontrolera i zaktualizuje wszystkie zmienione atrybuty. Zauważ, że plikupdate metoda nie potrzebuje żadnego pliku widoku, ponieważ używa jednego z nich show lub edit metody pokazania wyników.

Tworzenie pliku widoku do usunięcia Metoda

Usuwanie informacji z bazy danych za pomocą Ruby on Rails jest prawie zbyt łatwe. Nie musisz pisać żadnego kodu widoku dla metody delete, ponieważ ta metoda używalistmetoda, aby wyświetlić wynik. Więc po prostu zmodyfikujmy list.html.erb ponownie i dodajmy link do usuwania.

Przejdź do elementu <li> </li> i zmodyfikuj go, aby wyglądał następująco -

<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>

Plik :confirmwyświetla okno potwierdzenia JavaScript z pytaniem, czy naprawdę chcesz wykonać akcję. Jeśli użytkownik kliknie przycisk OK, akcja będzie kontynuowana, a element zostanie usunięty.

Teraz spróbuj przeglądać książki za pomocą http://localhost:3000/book/list. To daje listę wszystkich książek wraz z Edit i Delete opcje w następujący sposób -

Teraz, korzystając z opcji Usuń, możesz usunąć dowolny wymieniony rekord.

Tworzenie pliku widoku dla metody show_subjects

Utwórz nowy plik, show_subjects.html.erb, w katalogu app / views / book i dodaj do niego następujący kod -

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

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

Korzystasz ze skojarzeń, przeglądając wiele list książek z jednego przedmiotu.

Teraz zmodyfikuj wiersz Temat: w pliku show.html.erb, tak aby lista tematów zawierała łącze.

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

Spowoduje to wyświetlenie listy tematów na stronie indeksu, dzięki czemu użytkownicy będą mieli do nich bezpośredni dostęp.

Modyfikować list.html.erb aby dodać następujący tekst na początku pliku -

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

Teraz spróbuj przeglądać książki przy użyciu adresu http: // localhost: 3000 / book / list. Wyświetli wszystkie tematy z linkami, abyś mógł przeglądać wszystkie książki związane z tym tematem.

Co jest następne?

Mam nadzieję, że teraz czujesz się komfortowo ze wszystkimi operacjami w Railsach.

W następnym rozdziale wyjaśniono, jak używać Layoutsaby lepiej przedstawić swoje dane. Pokażemy Ci, jak używać CSS w aplikacjach Railsowych.

Układ definiuje otoczenie strony HTML. To miejsce, w którym można zdefiniować wspólny wygląd i styl końcowego produktu. Pliki układów znajdują się w app / views / layouts.

Proces obejmuje zdefiniowanie szablonu układu, a następnie poinformowanie kontrolera o jego istnieniu i użycie go. Najpierw utwórzmy szablon.

Dodaj nowy plik o nazwie standard.html.erb do app / views / layouts. Poinformuj kontrolerów, jakiego szablonu użyć, używając nazwy pliku, więc zaleca się stosowanie tego samego schematu nazewnictwa.

Dodaj następujący kod do nowego pliku standard.html.erb i zapisz zmiany -

<!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>

Wszystko, co właśnie dodałeś, to standardowe elementy HTML z wyjątkiem dwóch linii. Plikstylesheet_link_taghelper wyświetla arkusz stylów <link>. W tym przypadku łączymy arkusz stylów style.css. Plikyield polecenie informuje Railsy, że powinno umieścić plik html.erb dla wywoływanej tu metody.

Teraz otwarte book_controller.rb i dodaj następującą linię tuż pod pierwszą linią -

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

Instruuje kontroler, że chcemy użyć układu dostępnego w pliku standard.html.erb. Teraz spróbuj przeglądać książki, co spowoduje wyświetlenie następującego ekranu.

Dodawanie arkusza stylów

Do tej pory nie stworzyliśmy żadnego arkusza stylów, więc Railsy używają domyślnego arkusza stylów. Teraz stwórzmy nowy plik o nazwie style.css i zapiszmy go w / public / stylesheets. Dodaj następujący kod do tego pliku.

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;
}

Teraz odśwież przeglądarkę i zobacz różnicę -

Co jest następne?

Następny rozdział wyjaśnia, jak tworzyć aplikacje przy użyciu Rails Scaffolding, aby umożliwić użytkownikom dodawanie, usuwanie i modyfikowanie rekordów w dowolnej bazie danych.

Podczas tworzenia aplikacji Railsowych, szczególnie tych, które głównie zapewniają prosty interfejs do danych w bazie danych, często przydatne może być użycie metody szkieletowej.

Rusztowanie zapewnia więcej niż tanie emocje demonstracyjne. Oto kilka korzyści -

Możesz szybko przekazać użytkownikom kod w celu uzyskania opinii.
Motywuje Cię szybszy sukces.
Możesz dowiedzieć się, jak działają Railsy, patrząc na wygenerowany kod.
Możesz użyć rusztowania jako podstawy do szybkiego rozpoczęcia rozwoju.

Przykład rusztowania

Aby zrozumieć tworzenie szkieletów, utwórzmy bazę danych o nazwiecookbook i stół o nazwie recipes.

Tworzenie pustej aplikacji internetowej Rails

Otwórz okno poleceń i przejdź do miejsca, w którym chcesz to utworzyć cookbookAplikacja internetowa. Więc uruchom następujące polecenie, aby utworzyć pełną strukturę katalogów.

tp> rails new cookbook

Konfiguracja bazy danych

Oto sposób na utworzenie bazy danych -

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)

Aby poinstruować Railsy, jak znaleźć bazę danych, edytuj plik konfiguracyjny cookbook \ config \ database.yml i zmień nazwę bazy danych na cookbook. Zostaw hasło puste. Kiedy skończysz, powinno wyglądać następująco -

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

Railsy pozwalają na uruchamianie w trybie programistycznym, testowym lub produkcyjnym przy użyciu różnych baz danych. Ta aplikacja używa tej samej bazy danych dla każdego.

Wygenerowany kod szkieletu

Dzięki akcji scaffold Railsy generują cały kod, którego potrzebuje, dynamicznie. Uruchamiając scaffold jako skrypt, możemy pobrać cały kod zapisany na dysku, gdzie możemy go zbadać, a następnie zacząć dostosowywać go do naszych wymagań.

Więc teraz zacznijmy od nowa, aby ręcznie wygenerować kod Scaffolda za pomocą skryptu pomocniczego scaffold -

cookbook> rails generate scaffold recipe

Generuje automatyczne pliki, jak pokazano poniżej -

Administrator

Spójrzmy na kod za kontrolerem. Ten kod jest generowany przezscaffoldgenerator. Jeśli otworzysz app / controllers / recipes_controller.rb, znajdziesz coś takiego -

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

Gdy użytkownik aplikacji Railsowej wybierze akcję, np. „Show” - kontroler wykona dowolny kod w odpowiedniej sekcji - „def show” - a następnie domyślnie wyrenderuje szablon o tej samej nazwie - „show.html”. erb ”. To domyślne zachowanie można zastąpić.

Kontroler używa metod ActiveRecord, takich jak find, find_all, new, save, update_attributes i destru, aby przenosić dane do iz tabel bazy danych. Zauważ, że nie musisz pisać żadnych instrukcji SQL, railsy zajmą się tym automatycznie.

Ta pojedyncza linia kodu ożywi tabelę bazy danych. Zapewni prosty interfejs do Twoich danych i sposoby -

Tworzenie nowych wpisów
Edycja aktualnych wpisów
Przeglądanie aktualnych wpisów
Niszczenie aktualnych wpisów

Podczas tworzenia lub edytowania wpisu scaffold wykona za Ciebie całą ciężką pracę, taką jak generowanie i obsługa formularzy, a nawet zapewni sprytne generowanie formularzy, obsługując następujące typy danych wejściowych -

Proste ciągi tekstowe
Obszary tekstowe (lub duże bloki tekstu)
Selektory daty
Selektory daty i godziny

Możesz użyć migracji Rails do tworzenia i utrzymywania tabel.

rake db:migrate RAILS_ENV=development

Teraz przejdź do katalogu książki kucharskiej i uruchom serwer WWW za pomocą następującego polecenia -

cookbook> rails server

Teraz otwórz przeglądarkę i przejdź do http://127.0.0.1:3000/recipe/new. Spowoduje to wyświetlenie ekranu umożliwiającego tworzenie nowych wpisów w tabeli receptur. Zrzut ekranu pokazano poniżej -

Po naciśnięciu Create aby utworzyć nową recepturę, Twój rekord zostanie dodany do tabeli receptur i pokaże następujący wynik -

Możesz zobaczyć opcję edycji, wyświetlania i niszczenia rekordów. Więc baw się z tymi opcjami.

Można również wyświetlić listę wszystkich przepisów dostępnych w tabeli przepisów, korzystając z adresu URL http://127.0.0.1:3000/recipe/list.

Udoskonalanie modelu

Railsy oferują mnóstwo darmowej obsługi błędów. Aby to zrozumieć, dodaj kilka reguł weryfikacji do pustego modelu receptury -

Zmodyfikuj app / models / recipe.rb w następujący sposób, a następnie przetestuj swoją aplikację -

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

Te wpisy zapewnią automatyczne sprawdzenie.

validates_length_of - pole nie jest puste i niezbyt długie.
validates_uniqueness_of- zduplikowane wartości są przechwytywane. Zamiast domyślnego komunikatu o błędzie Railsów, podaliśmy tutaj niestandardowy komunikat.

Alternatywny sposób tworzenia rusztowań

Utwórz aplikację, jak pokazano powyżej i The Generated Scaffold Code jak pokazano niżej

rails g scaffold Recipe tittle:string instructions:text

Powyższy kod generuje pliki auto z bazą danych przy użyciu z sqlite3 z tytułem i kolumną z instrukcjami, jak pokazano poniżej.

musimy przeprowadzić migrację bazy danych przy użyciu poniższej składni.

$ rake db:migrate RAILS_ENV=development

Na koniec uruchom aplikację, używając następującego wiersza poleceń -

rails server

Wygeneruje wynik, jak pokazano powyżej obrazy wyjściowe.

Widoki

Wszystkie widoki i odpowiadające im wszystkie metody kontrolera są tworzone przez scaffold polecenia i są dostępne w katalogu app / views / recipes.

Czym różni się rusztowanie?

Jeśli przejrzałeś poprzednie rozdziały, to na pewno widziałeś, że stworzyliśmy metody listowania, pokazywania, usuwania i tworzenia danych itp., Ale rusztowanie wykonuje to zadanie automatycznie.

Ajax oznacza Asynchroniczny JavaScript i XML. Ajax nie jest pojedynczą technologią; jest to zestaw kilku technologii. Ajax zawiera następujące elementy -

XHTML do oznaczania stron internetowych
CSS do stylizacji
Dynamiczne wyświetlanie i interakcja z wykorzystaniem DOM
Manipulowanie danymi i wymiana za pomocą XML
Pobieranie danych za pomocą XMLHttpRequest
JavaScript jako klej, który spaja to wszystko razem

Ajax umożliwia pobieranie danych do strony internetowej bez konieczności odświeżania zawartości całej strony. W podstawowej architekturze sieciowej użytkownik klika łącze lub przesyła formularz. Formularz jest przesyłany do serwera, który następnie odsyła odpowiedź. Odpowiedź jest następnie wyświetlana użytkownikowi na nowej stronie.

Kiedy wchodzisz w interakcję ze stroną internetową opartą na Ajax, ładuje ona silnik Ajax w tle. Silnik jest napisany w JavaScript, a jego zadaniem jest zarówno komunikacja z serwerem WWW, jak i wyświetlanie wyników użytkownikowi. Gdy przesyłasz dane za pomocą formularza opartego na technologii Ajax, serwer zwraca fragment HTML zawierający odpowiedź serwera i wyświetla tylko dane, które są nowe lub zmienione, zamiast odświeżania całej strony.

Aby uzyskać szczegółowe informacje na temat AJAX, przejdź do naszego samouczka AJAX

Jak Railsy implementują Ajax

Railsy mają prosty, spójny model implementacji operacji Ajax. Gdy przeglądarka wyrenderuje i wyświetli początkową stronę internetową, różne działania użytkownika powodują wyświetlenie nowej strony internetowej (jak każda tradycyjna aplikacja internetowa) lub wywołanie operacji Ajax -

Some trigger fires - Tym wyzwalaczem może być kliknięcie przez użytkownika przycisku lub łącza, użytkownik wprowadzający zmiany w danych w formularzu lub polu lub po prostu okresowy wyzwalacz (oparty na liczniku czasu).
The web client calls the server- Metoda JavaScript, XMLHttpRequest , wysyła dane powiązane z wyzwalaczem do modułu obsługi akcji na serwerze. Dane mogą być identyfikatorem pola wyboru, tekstem w polu wprowadzania lub całym formularzem.
The server does processing - Program obsługi akcji po stronie serwera (akcja kontrolera Railsów) - robi coś z danymi i zwraca fragment HTML do klienta WWW.
The client receives the response - JavaScript po stronie klienta, który Railsy tworzy automatycznie, otrzymuje fragment HTML i używa go do aktualizacji określonej części kodu HTML bieżącej strony, często zawartości tagu <div>.

Te kroki są najprostszym sposobem użycia Ajax w aplikacji Railsowej, ale przy odrobinie dodatkowej pracy możesz sprawić, aby serwer zwrócił dowolne dane w odpowiedzi na żądanie Ajax, a także możesz utworzyć niestandardowy JavaScript w przeglądarce, aby wykonać więcej zaangażowane interakcje.

Przykład AJAX

Ten przykład działa w oparciu o scaffold, koncepcja Destroy działa w oparciu o Ajax.

W tym przykładzie dostarczymy, wyszczególnimy, pokażemy i utworzymy operacje na stole kucyków. Jeśli nie rozumiesz technologii rusztowań, sugerujemy, abyś najpierw przejrzał poprzednie rozdziały, a następnie kontynuował pracę z AJAX on Rails.

Tworzenie aplikacji

Zacznijmy od stworzenia aplikacji.Zrobimy to następująco -

rails new ponies

Powyższe polecenie tworzy aplikację, teraz musimy wywołać katalog aplikacji za pomocą polecenia cd. Wejdzie do katalogu aplikacji, a następnie musimy wywołać polecenie szkieletu. Zostanie to zrobione w następujący sposób -

rails generate scaffold Pony name:string profession:string

Powyższe polecenie generuje rusztowanie z kolumną z nazwą i profesją. Musimy przeprowadzić migrację bazy danych w następujący sposób

rake db:migrate

Teraz uruchom aplikację Rails w następujący sposób

rails s

Teraz otwórz przeglądarkę internetową i wywołaj adres URL jako http: // localhost: 3000 / pony / new, dane wyjściowe będą następujące

Tworzenie Ajax

Teraz otwórz app / views / pony / index.html.erb z odpowiednimi edytorami tekstu. Zaktualizuj swoją linię zniszczenia za pomocą: remote => true,: class => 'delete_pony'. Na koniec wygląda to następująco.

Utwórz plik, zniszcz.js.erb, umieść go obok innych plików .erb (w sekcji app / views / pucki). Powinien wyglądać tak -

Teraz wprowadź kod, jak pokazano poniżej w destru.js.erb

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

Teraz otwórz plik kontrolera, który znajduje się w app / controllers / pony_controller.rb i dodaj następujący kod do metody niszczenia, jak pokazano poniżej -

# 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

W końcu strona kontrolera jest taka, jak pokazano na obrazku.

Teraz uruchom aplikację, Wyjście wywołane z http: // localhost: 3000 / pony / new, będzie wyglądać jak na poniższym obrazku

Naciśnij przycisk tworzenia kucyka, wygeneruje wynik w następujący sposób

Teraz kliknij przycisk Wstecz, pokaże wszystkie informacje utworzone przez kucyka, jak pokazano na obrazku

Do tej pory pracujemy na rusztowaniu, teraz kliknij przycisk zniszcz, wywoła wyskakujące okienko, jak pokazano na poniższym obrazku, pop-up działa w oparciu o Ajax.

Kliknięcie przycisku OK spowoduje usunięcie rekordu z kucyka. Tutaj kliknąłem przycisk OK. Ostateczny wynik będzie następujący -

Możesz mieć wymaganie, w którym chcesz, aby użytkownicy witryny przesyłali plik na serwer. Szyny bardzo ułatwiają spełnienie tego wymagania. Teraz przejdziemy do prostego i małego projektu Railsów.

Jak zwykle zacznijmy od nowej aplikacji Railsowej o nazwie testfile. Stwórzmy podstawową strukturę aplikacji za pomocą prostego polecenia rails.

tp> rails new testfile

Przed rozpoczęciem tworzenia aplikacji powinniśmy zainstalować pliki gem, jak pokazano poniżej -

gem install carrierwave
gem install bootstrap-sass

Otwórz swój plik klejnotów i dodaj następujące dwa klejnoty na dole, jak pokazano na poniższym obrazku -

Po dodaniu klejnotów w pliku gemów musimy uruchomić na konsoli następującą komendę -

bundle install

Tworzenie modelu

Musimy stworzyć model z dwoma ciągami jako nazwą i załącznikiem, jak pokazano poniżej -

rails g model Resume name:string attachment:string

Musimy utworzyć migrację bazy danych, jak pokazano poniżej -

rake db:migrate

Musimy wygenerować kontroler, jak pokazano poniżej -

rails g controller Resumes index new create destroy

Świetny! Teraz mamy skonfigurowaną podstawową strukturę. Teraz musimy stworzyć uploader. Program do przesyłania pochodzi z gemu carrierwave i mówi przewoźnikowi, jak postępować z plikami. Krótko mówiąc, zawierał wszystkie funkcje przetwarzania plików. Uruchom polecenie, aby utworzyć program do przesyłania, jak pokazano poniżej

rails g uploader attachment

Teraz otwórz model CV i zadzwoń do osoby przesyłającej, jak pokazano poniżej. Model CV umieszczony w 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

Przed rozpoczęciem pracy nad kontrolerem musimy zmodyfikować nasz plik config / tours.db, jak pokazano poniżej -

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

Pozwala nam edytować kontroler, jak pokazano poniżej.

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

Dodajmy implementację bootstrap w pliku css.css może znajdować się w app / asset / stylesheets / resumes.css.scss

@import "bootstrap";

Teraz otwórz app / views / layouts / application.html.erb i dodaj kody, jak pokazano poniżej -

<!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>

Teraz musimy skonfigurować widoki indeksu, jak pokazano poniżej -

<% 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>

Teraz edytujmy new.html.erb i dodajmy nasz kod formularza.

<% 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>

Teraz uruchom serwer i odwiedź http: // localhost: 3000. Wyświetli ekran podobny do następującego -

Ostatnią rzeczą, którą musimy zrobić, jest przefiltrowanie listy dozwolonych typów plików. W tym celu musimy dodać prosty kod, jak pokazano poniżej w app / uploaders / attach_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

Teraz uruchom serwer i odwiedź http: // localhost: 3000. Teraz wprowadź zły format; wygeneruje zły komunikat, jak pokazano poniżej -

Aby uzyskać szczegółowe informacje na temat File obiekt, musisz przejść przez Ruby Reference Manual.

Action Mailerto komponent Rails, który umożliwia aplikacjom wysyłanie i odbieranie wiadomości e-mail. W tym rozdziale zobaczymy, jak wysłać wiadomość e-mail za pomocą Railsów. Zacznijmy tworzyćemails projekt za pomocą następującego polecenia.

tp> rails new mailtest

Stworzy to ramy wymagane do kontynuowania. Teraz zaczniemy od konfiguracji ActionMailer.

Action Mailer - Konfiguracja

Poniżej przedstawiono kroki, które należy wykonać, aby zakończyć konfigurację przed przystąpieniem do właściwej pracy -

Przejdź do folderu config projektu wiadomości e-mail i otwórz plik environment.rb i dodaj następujący wiersz na dole tego pliku.

config.action_mailer.delivery_method = :smtp

Informuje ActionMailer, że chcesz używać serwera SMTP. Możesz również ustawić go na: sendmail, jeśli używasz systemu operacyjnego opartego na Uniksie, takiego jak Mac OS X lub Linux.

Dodaj następujące wiersze kodu również u dołu pliku 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  
}

Zastąp każdą wartość skrótu właściwymi ustawieniami dla serwera Simple Mail Transfer Protocol (SMTP). Możesz uzyskać te informacje od swojego dostawcy usług internetowych, jeśli jeszcze nie wiesz. Nie musisz zmieniać numeru portu 25 i typu uwierzytelniania, jeśli używasz standardowego serwera SMTP.

Możesz także zmienić domyślny format wiadomości e-mail. Jeśli wolisz wysyłać wiadomości e-mail w formacie HTML zamiast zwykłego tekstu, dodaj również następujący wiersz do pliku config / environment.rb -

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

ActionMailer :: Base.default_content_type można ustawić na „tekst / zwykły”, „tekst / html” i „tekst / wzbogacony”. Wartość domyślna to „tekst / zwykły”.

Następnym krokiem będzie utworzenie mailera

Wygeneruj Mailer

Użyj następującego polecenia, aby wygenerować pocztę w następujący sposób -

tp> cd emails
emails> rails generate mailer Usermailer

Spowoduje to utworzenie pliku user_mailer.rb w katalogu app \ mailer. Sprawdź zawartość tego pliku w następujący sposób -

class Emailer < ActionMailer::Base
end

Utwórzmy jedną metodę w następujący sposób -

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- To jest skrót wartości domyślnych dla każdego e-maila wysyłanego z tej poczty. W tym przypadku ustawiamy: from nagłówek na wartość dla wszystkich wiadomości w tej klasie. Można to zmienić na podstawie wiadomości e-mail
mail - Właściwa wiadomość e-mail, w której przekazujemy nagłówki: do i:.

Utwórz plik o nazwie welcome_email.html.erb w app / views / user_mailer /. Będzie to szablon używany do wiadomości e-mail, sformatowany w 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>

Następnie utworzymy część tekstową dla tej aplikacji w następujący sposób -

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!

Dzwonię do kuriera

Najpierw utwórzmy proste szkielet użytkownika

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

Action Mailer jest ładnie zintegrowany z Active Job, dzięki czemu możesz wysyłać e-maile poza cyklem żądanie-odpowiedź, więc użytkownik nie musi na to czekać -

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

Teraz przetestuj swoją aplikację, używając adresu http://127.0.0.1:3000/users/new. Wyświetla następujący ekran i korzystając z tego ekranu, będziesz mógł wysłać wiadomość do każdego.

Spowoduje to wysłanie wiadomości i wyświetlenie wiadomości tekstowej „Wiadomość wysłana pomyślnie” i wyświetlenie w następujący sposób -

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

Aby uzyskać więcej informacji na temat wysyłania wiadomości e-mail za pomocą Rails, przejdź do ActionMailer .