Ten przewodnik opisuje instalację i uruchamianie Ruby on Rails.

Po jej przeczytaniu będziesz wiedział:

• Jak zainstalować Railsy, ​​stworzyć nową aplikację Railsową i połączyć swoją aplikację z bazą danych.
• Ogólna struktura aplikacji Rails.
• Podstawowe zasady MVC (Model, View Controller - "Model-View-Controller") oraz projektowanie w oparciu o RESTful.
• Jak szybko wygenerować początkowy kod aplikacji Railsowej.

Założenia w tym przewodniku

Ten przewodnik jest przeznaczony dla początkujących, którzy chcą rozpocząć aplikację Railsową od zera. Nie zakłada się, że wcześniej pracowałeś z Railsami.

Rails to framework do tworzenia stron internetowych napisany w języku programowania Ruby. Jeśli nie masz doświadczenia z Ruby, może być ci trudno od razu zacząć uczyć się Railsów. Istnieje kilka dobrych anglojęzycznych zasobów poświęconych nauce języka Ruby, na przykład:

Zauważ, że niektóre zasoby, choć wciąż świetne, nadal obejmują starsze wersje Rubiego, takie jak w szczególności 1.6 i 1.8, i nie zawierają części składni, którą zobaczysz podczas codziennego programowania w Railsach.

Co to jest Railsy?

Rails to framework do tworzenia stron internetowych napisany w języku programowania Ruby. Został zaprojektowany, aby ułatwić programowanie aplikacji internetowych, przyjmując szereg założeń dotyczących tego, czego każdy programista potrzebuje do stworzenia nowego projektu. Pozwala napisać mniej kodu podczas programowania w porównaniu do innych języków i frameworków. Profesjonalni programiści na Railsach również zauważają, że tworzenie aplikacji internetowych jest dzięki temu przyjemniejsze =)

Railsy to mistrzowskie oprogramowanie. Przyjmuje założenie, że istnieje „najlepszy” sposób na zrobienie czegoś i ma na celu zachęcanie do tego sposobu - aw niektórych przypadkach nawet zniechęcanie do alternatyw. Jeśli studiujesz „The Rails Way”, możesz odkryć w sobie znaczny wzrost produktywności. Jeśli wytrwasz i przeniesiesz stare nawyki z innych języków do rozwoju Rails i spróbujesz użyć wzorców wyuczonych gdzie indziej, twoje doświadczenie programistyczne będzie mniej niż szczęśliwe.

Filozofia Rails obejmuje dwie ważne zasady przewodnie:

• Nie powtarzaj się: DRY to zasada inżynierii oprogramowania, która stwierdza, że ​​„Każda informacja powinna mieć pojedynczą, nieredundantną, autorytatywną reprezentację w systemie”. Nie pisz w kółko tych samych informacji, kod będzie łatwiejszy w utrzymaniu, bardziej rozszerzalny i mniej błędny.
• Konwencja nad konfiguracją: Railsy mają opinie na temat najlepszego sposobu robienia wielu rzeczy w aplikacji internetowej i domyślnie stosują się do tych konwencji, zamiast zmuszać cię do dostrajania wielu plików konfiguracyjnych.

Tworzenie nowego projektu Rails

Najlepszym sposobem korzystania z tego przewodnika jest zapoznanie się z nim krok po kroku. Wszystkie kroki są niezbędne do uruchomienia przykładowej aplikacji i nie jest wymagany żaden dodatkowy kod ani kroki.

Postępując zgodnie z tym samouczkiem, utworzysz projekt Rails o nazwie blog , bardzo prosty blog internetowy. Zanim zaczniemy budować aplikację, musimy upewnić się, że sam Rails jest zainstalowany.

Poniższe przykłady używają znaku $ do oznaczenia linii wejściowej terminala w systemie UNIX system operacyjny aha, chociaż można to inaczej skonfigurować. Jeśli używasz systemu Windows, wiersz będzie wyglądał mniej więcej tak: c:\source_code>

3.1. Instalowanie szyn

Przed zainstalowaniem Railsów musisz upewnić się, że masz zainstalowane wymagane wymagania wstępne w swoim systemie. Należą do nich Ruby i SQLite3.

Otwórz aplikacje dla wiersz poleceń. W systemie macOS otwórz Terminal.app, w systemie Windows wybierz „Uruchom” z menu Start i wpisz „cmd.exe”. Wszystkie polecenia zaczynające się od znaku dolara $ muszą być uruchamiane w wierszu poleceń. Upewnij się, że masz zainstalowaną aktualną wersję Ruby:

$ ruby ​​​​-v rubin 2.5.0

Railsy wymagają zainstalowania Ruby w wersji 2.5.0 lub nowszej. Jeśli numer wersji jest mniejszy niż ten, będziesz musiał zainstalować nową kopię Ruby.

Aby szybko zainstalować Ruby i Ruby on Rails w swoim systemie, Użytkownicy Windowsa może użyć instalatora Rails. Dodatkowe metody instalacji dla większości systemów operacyjnych można znaleźć na stronie ruby-lang.org.

Jeśli korzystasz z systemu Windows, musisz zainstalować Ruby Installer Development Kit.

Będziesz także musiał zainstalować bazę danych SQLite3.

Wiele popularnych systemów operacyjnych typu UNIX jest dostarczanych z akceptowalną wersją oprogramowania SQLite3. W systemie Windows, jeśli zainstalowałeś Railsy za pomocą instalatora Rails, masz już zainstalowany SQLite. Inni użytkownicy mogą zapoznać się z instrukcjami instalacji na stronie SQLite3. Sprawdź, czy jest poprawnie zainstalowany i czy znajduje się w Twojej ŚCIEŻCE:

$ sqlite3 --wersja

Program powinien zgłaszać swoją wersję.

Aby zainstalować Railsy, ​​użyj polecenia gem install dostarczonego przez RubyGems:

$ gem zainstalować szyny

Aby sprawdzić, czy wszystko jest poprawnie zainstalowane, musisz wykonać następujące czynności:

$ szyny --wersja

Jeśli wyświetli się coś takiego jak „Rails 6.0.0”, możesz kontynuować.

3.2. Tworzenie aplikacji blogowej

Railsy są dostarczane z wieloma skryptami, zwanymi generatorami, zaprojektowanymi, aby ułatwić życie programistom, tworząc wszystko, czego potrzebują, aby rozpocząć określone zadanie. Jednym z nich jest nowy generator aplikacji, który zapewnia podstawę aplikacji Railsowej, dzięki czemu nie musisz jej pisać samodzielnie.

Aby użyć tego generatora, otwórz terminal, przejdź do folderu, w którym masz uprawnienia do tworzenia plików, i napisz:

Nowy blog $ Rails

Spowoduje to utworzenie aplikacji Rails o nazwie Blog w katalogu blog i zainstalowanie klejnotów, których zależności są wymienione w Gemfile podczas korzystania z bundle install .

Na przy użyciu Windowsa Podsystem dla systemu Linux, istnieją pewne ograniczenia dotyczące komunikatów system plików aby wyłączyć klejnoty wiosenne i nasłuchiwać, co można zrobić, uruchamiając nowy blog Rails --skip-spring --skip-listen .

Możesz zobaczyć wszystkie możliwe opcje wiersza poleceń, które kreator aplikacji Rails akceptuje, uruchamiając Rails new -h .

Po utworzeniu aplikacji blogu przejdź do jej folderu:

Katalog blogów zawiera kilka automatycznie generowanych plików i folderów, które definiują strukturę aplikacji Rails. Większość pracy w tym samouczku będzie miała miejsce w folderze aplikacji, ale na razie przejrzyjmy funkcje każdego folderu, który Rails tworzy w nowej domyślnej aplikacji:

Folder plików	Zamiar
aplikacja/	Zawiera kontrolery, modele, widoki, pomocników, programy pocztowe, kanały, zadania i zasoby Twojej aplikacji. Później przyjrzymy się temu folderowi bardziej szczegółowo.
kosz/	Zawiera skrypty Rails, które uruchamiają twoją aplikację, a katalog może również zawierać inne skrypty, których używasz do konfigurowania, aktualizowania, wdrażania lub uruchamiania.
konfiguracja/	Konfiguracje tras, bazy danych Twojej aplikacji itp. Jest to omówione bardziej szczegółowo w Konfigurowanie aplikacji Rails.
config.ru	Konfiguracja stelaża dla serwerów stelażowych używanych do uruchamiania aplikacji. Aby uzyskać więcej informacji na temat Rack, odwiedź witrynę Rack.
db/	Zawiera bieżący schemat bazy danych oraz migracje bazy danych.
plik gem Gemfile.lock	Te pliki pozwalają ci określić, jakich zależności klejnotów potrzebuje twoja aplikacja Railsowa. Te pliki są używane przez klejnot Bundlera. Aby uzyskać więcej informacji na temat programu Bundler, zobacz witrynę programu Bundler.
biblioteka/	Zewnętrzne moduły dla Twojej aplikacji.
dziennik/	Pliki dziennika aplikacji.
pakiet.json	Ten plik pozwala określić, które zależności npm są wymagane dla Twojej aplikacji Railsowej. Ten plik jest używany przez Yarn. Aby uzyskać więcej informacji na temat przędzy, zobacz witrynę internetową przędzy.
publiczny/	Jedyny folder, który jest dostępny z zewnątrz. Zawiera pliki statyczne i skompilowane zasoby.
Rakefile	Ten plik wyszukuje i ładuje zadania, które można uruchomić w wierszu poleceń. Zdefiniowane zadanie jest dostępne we wszystkich komponentach Rails. Zamiast zmieniać plik Rakefile, możesz dodać własne zadania, dodając pliki do katalogu lib/tasks aplikacji.
PRZECZYTAJ.md	To jest podręcznik wprowadzający do Twojej aplikacji. Należy go edytować, aby poinformować innych, co robi Twoja aplikacja, jak ją skonfigurować i tak dalej.
składowanie/	Pliki Active Storage dla usługi Dysk. Jest to omówione w przewodniku Przegląd usługi Active Storage.
test/	Testy jednostkowe, osprzęt i inna aparatura testująca. Jest to omówione w przewodniku Testowanie aplikacji Rails.
tmp/	Pliki tymczasowe (takie jak pliki pamięci podręcznej i pliki pid)
sprzedawca/	Miejsce na kod strony trzeciej. W typowej aplikacji Railsowej zawiera ona zewnętrzne klejnoty.
gitignore	Ten plik mówi gitowi, które pliki (jawne lub wieloznaczne) powinien zignorować. Zobacz GitHub — ignorowanie plików, aby uzyskać więcej informacji na temat ignorowania plików.
wersja .ruby	Ten plik zawiera domyślną wersję Ruby.

Witaj Rails!

Najpierw wyświetlmy tekst na ekranie. Wymaga to działającego serwera dla Twojej aplikacji Rails.

4.1. Uruchomienie serwera WWW

W rzeczywistości masz już funkcjonalną aplikację Railsową. Aby mieć pewność, musisz uruchomić serwer WWW na swoim komputerze. Można to zrobić, uruchamiając następujące polecenie z katalogu blogów:

Jeśli korzystasz z systemu Windows, musisz przekazać skrypty z folderu bin bezpośrednio do interpretera Ruby, czyli serwera ruby ​​bin\rails.

Kompresja zasobów JavaScript wymaga środowiska uruchomieniowego JavaScript w systemie, a jego brak spowoduje błąd execjs podczas kompresji zasobów. Zazwyczaj macOS i Windows są dostarczane z zainstalowanym środowiskiem wykonawczym JavaScript. therubyrhino jest zalecanym środowiskiem wykonawczym dla użytkowników JRuby i jest dodawane do Gemfile, jeśli aplikacja jest generowana dla JRuby. Możesz dowiedzieć się wszystkiego o obsługiwanych środowiskach wykonawczych w ExecJS

Spowoduje to uruchomienie Puma, serwera WWW dystrybuowanego domyślnie z Railsami. Aby zobaczyć aplikację w akcji, otwórz okno przeglądarki i przejdź do http://localhost:3000 . Powinieneś zobaczyć domyślną stronę informacji o Railsach:

Aby zatrzymać serwer WWW, naciśnij klawisze Ctrl+C w terminalu, w którym jest uruchomiony. Aby sprawdzić, czy serwer został zatrzymany, powinieneś ponownie zobaczyć kursor wiersza poleceń. W przypadku większości systemów typu UNIX, w tym macOS, będzie to znak dolara $ . W trybie programistycznym Railsy generalnie nie wymagają zatrzymywania serwera; wszystkie zmiany dokonane w plikach są automatycznie pobierane przez serwer.

Strona „Witamy na pokładzie” jest jak test dla nowej aplikacji Railsowej: pokazuje, że twoje programy są skonfigurowane wystarczająco poprawnie, aby wyświetlić stronę.

4.2. Przywitaj się z Railsami

Aby Railsy powiedziały „Cześć”, musisz utworzyć co najmniej kontroler I pogląd(wydajność).

Celem kontrolera jest otrzymywanie określonych żądań do aplikacji. Rozgromienie decyduje, który kontroler otrzyma które żądania. Często do każdego kontrolera prowadzi więcej niż jedna trasa, a różne trasy mogą być obsługiwane w różny sposób. gry akcji. Celem każdej akcji jest zebranie informacji w celu dostarczenia ich do widoku.

Celem widoku jest wyświetlenie tych informacji w formacie czytelnym dla człowieka. Ważnym rozróżnieniem, jakie należy wprowadzić, jest miejsce, w którym gromadzone są informacje kontroler, nie widok. Widok powinien wyświetlać tylko te informacje. Domyślnie szablony widoków są napisane w języku zwanym eRuby (Embedded Ruby), który jest konwertowany przez pętlę żądań w Railsach przed wysłaniem do użytkownika.

Aby utworzyć nowy kontroler, musisz uruchomić generator „kontrolera” i powiedzieć mu, że chcesz kontroler o nazwie „Witamy” z akcją o nazwie „indeks”, na przykład:

$ rails generuje indeks powitalny kontrolera

Railsy utworzą kilka plików i trasę.

Utwórz aplikację/kontrolery/welcome_controller.rb trasa pobierz „welcome/index” wywołaj erb utwórz aplikację/views/welcome utwórz aplikację/views/welcome/index.html.erb wywołaj test_unit utwórz test/controllers/welcome_controller_test.rb wywołaj pomocnika utwórz aplikację/ helpers/welcome_helper.rb wywołaj test_unit wywołaj zasoby wywołaj scss utwórz aplikację/assets/stylesheets/welcome.scss

Najważniejsze z nich to oczywiście kontroler znajdujący się w app/controllers/welcome_controller.rb oraz widok znajdujący się w app/views/welcome/index.html.erb .

Otwórz plik app/views/welcome/index.html.erb w edytorze tekstu. Usuń cały istniejący kod w pliku i zastąp go następującym wierszem kodu:

Jeśli ponownie wyślesz formularz, zobaczysz coś takiego:

"Pierwszy artykuł!", "text"=>"To jest mój pierwszy artykuł.") dozwolone: ​​false>

Ta akcja wyświetla teraz opcje artykułu pochodzącego z formularza. Jednak nadal jest bezużyteczny. Tak, widzisz parametry, ale tak naprawdę nic z nimi nie robisz.

5.4. Tworzenie modelu artykułu

Modele w Railsach używają nazwy w liczbie pojedynczej, a odpowiadająca im tabela w bazie danych używa nazwy w liczbie mnogiej. Railsy dostarczają generator modeli, którego większość programistów Rails używa do tworzenia nowych modeli. Aby utworzyć nowy model, uruchom to polecenie w swoim terminalu:

$ rails generuje model Tytuł artykułu:string tekst:tekst

Za pomocą tego polecenia mówimy Railsom, że chcemy modelu artykułu z atrybutem tytuł typ ciągu i atrybut tekst typ tekstu. Atrybuty te są automatycznie dodawane do tabeli artykułów i powiązane z modelem artykułów.

W odpowiedzi Railsy utworzy serię plików. W tej chwili interesują nas tylko app/models/article.rb i db/migrate/20140120191729_create_articles.rb (Twoje imię może być nieco inne). Ten ostatni odpowiada za stworzenie struktury bazy danych, dlatego przyjrzymy się mu dalej.

Active Record jest wystarczająco inteligentny, aby automatycznie kojarzyć nazwy kolumn z atrybutami modelu, co oznacza, że ​​nie musisz deklarować atrybutów wewnątrz modeli Rails, Active Record robi to automatycznie.

5.5. Uruchamianie migracji

Jak widzieliście, Railsy generują model utworzony w pliku migracje baz danych w katalogu db/migrate. Migracje to klasa języka Ruby zaprojektowana w celu ułatwienia tworzenia i modyfikowania tabel bazy danych. Railsy używają poleceń rake do przeprowadzania migracji i możliwe jest cofnięcie migracji po jej zastosowaniu do bazy danych. Nazwa pliku migracji zawiera sygnaturę czasową, aby upewnić się, że są uruchamiane w kolejności, w jakiej zostały utworzone.

Jeśli zajrzysz do pliku db/migrate/YYYYMMDDHHMMSS_create_articles.rb (pamiętaj, że twój plik ma nieco inną nazwę), oto co znajdziesz:

Klasa Utwórz artykuły< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Ta migracja tworzy metodę zmiany, która jest wywoływana, gdy ta migracja jest uruchamiana. Akcja zdefiniowana w tej migracji jest również odwracalna, co oznacza, że ​​Rails wie, jak cofnąć zmiany wprowadzone przez tę migrację, na wypadek gdybyś zdecydował się cofnąć je później. Po uruchomieniu tej migracji zostanie utworzona tabela artykułów z kolumną łańcuchową i kolumną tekstową. Utworzy również dwa pola znaczników czasu, aby śledzić, kiedy artykuł został utworzony i zaktualizowany.

Teraz musimy użyć polecenia Rails, aby uruchomić migrację:

$ Rails db:migracja

Railsy uruchomią to polecenie migracji i zgłoszą, że utworzyły tabelę Artykuły.

Utwórz artykuły: migracja ============================================ == = -- create_table(:artykuły) -> 0.0019s == CreateArticles: migracja (0.0020s) =========================== == ============

Ponieważ domyślnie pracujesz w środowisku programistycznym, to polecenie zostanie zastosowane do bazy danych zdefiniowanej w sekcji programistycznej pliku config/database.yml. Jeśli chcesz uruchomić migracje w innym środowisku, takim jak produkcja, musisz je jawnie przekazać, wywołując polecenie: rails db:migrate RAILS_ENV=production .

5.6. Zapisywanie danych w sterowniku

Wracając do ArticlesController , musimy zmodyfikować akcję tworzenia, aby używała nowego modelu Article do zapisywania danych w bazie danych. Otwórz app/controllers/articles_controller.rb i zmodyfikuj akcję tworzenia w następujący sposób:

Def create @artykuł = Article.new(parametry[:artykuł]) @article.save redirect_to @koniec artykułu

Oto, co się tutaj dzieje: każdy model Rails może zostać zainicjowany z odpowiednimi atrybutami, które zostaną automatycznie powiązane z odpowiednimi kolumnami bazy danych. W pierwszym wierszu właśnie to robimy (pamiętajmy, że params[:article] zawiera interesujące nas atrybuty). Następnie @article.save odpowiada za zapisanie modelu do bazy danych. Na koniec przekierowujemy użytkownika do akcji show, którą zdefiniujemy później.

Być może zastanawiasz się, dlaczego litera A w artykule Article.new jest pisana wielką literą, skoro wszystkie inne linki do artykułów w tym przewodniku są pisane małymi literami. W tym kontekście odnosimy się do klasy o nazwie Article , która jest zdefiniowana w app/models/article.rb . Nazwy klas w języku Ruby muszą zaczynać się od dużej litery.

Teraz, gdy istnieją walidacje, wywołanie @article.save na nieprawidłowym artykule zwróci false . Jeśli ponownie otworzysz app/controllers/articles_controller.rb, zobaczysz, że nie sprawdzamy wyniku wywołania @article.save w akcji create. Jeśli @article.save nie powiedzie się w tej sytuacji, musimy ponownie pokazać użytkownikowi formularz. Aby to zrobić, zastąp akcje new i create w app/controllers/articles_controller.rb tymi:

Def new @artykuł = Artykuł.nowy koniec def create @artykuł = Artykuł.nowy(parametry_artykułu) if @artykuł.save redirect_to @artykuł else renderuje "nowy" end end private defparametry_artykułu params.require(:artykuł).pozwolenie(:tytuł , :tekst) koniec

Teraz nowa akcja tworzy nową zmienną instancji o nazwie @article , a zobaczysz, dlaczego w kilku akapitach.

Zauważ, że w akcji create użyliśmy render zamiast redirect_to, gdy save zwraca false . Metoda render służy do przekazywania obiektu @article z powrotem do nowego szablonu podczas renderowania. To renderowanie odbywa się w ramach tego samego żądania, co przesłanie formularza, podczas gdy redirect_to mówi przeglądarce, aby wykonała kolejne żądanie.

5.11. Aktualizacje artykułów

Ujawniliśmy część „CR” CRUD. Teraz skupmy się na części „U”, aktualizowaniu artykułów.

Pierwszym krokiem jest dodanie akcji edit do ArticlesController , zwykle pomiędzy akcjami new i create, jak pokazano.

Def new @artykuł = Artykuł.nowy koniec def edit @article = Artykuł.znajdź(parametry[:id]) end def create @artykuł = Artykuł.nowy(parametry_artykułu) if @artykuł.zapisz redirect_to @artykuł else renderuj „nowy” koniec koniec

Widok będzie zawierał formularz podobny do tego, którego używaliśmy przy tworzeniu nowych artykułów. Utwórz plik o nazwie app/views/articles/edit.html.erb i dodaj do niego:

Redagowanie artykułu

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

W tej chwili kierujemy formularz na akcję aktualizacji, która nie jest jeszcze zdefiniowana, ale wkrótce to zrobimy.

Przekazanie obiektu article do metody form_with spowoduje automatyczne ustawienie adresu URL do przesłania edytowanego formularza artykułu. Ta opcja mówi Railsom, że chcemy, aby ten formularz został przesłany za pomocą PATCH , metody HTTP, która ma być używana do aktualizacje zasobów zgodnie z protokołem REST.

Następnie musisz utworzyć akcję aktualizacji w app/controllers/articles_controller.rb . Dodaj go między akcją tworzenia a metodą prywatną:

Def create @article = Article.new(parametry_artykułu) if @article.save redirect_to @artykuł else renderuje „nowy” end end def update @article = Article.find(params[:id]) if @article.update(parametry_artykułu) redirect_to @artykuł else renderuj „edytuj” koniec koniec prywatny def param_artykułu params.require(:artykuł).permit(:tytuł,:tekst) koniec

Nowa metoda, update , jest używana, gdy chcesz zaktualizować wpis, który już istnieje i wymaga skrótu zawierającego atrybuty, które chcesz zaktualizować. Tak jak poprzednio, jeśli podczas aktualizacji artykułu wystąpi błąd, chcemy ponownie pokazać użytkownikowi formularz.

Ponownie wykorzystaliśmy metodę article_params, którą zdefiniowaliśmy wcześniej dla akcji tworzenia.

Nie jest konieczne przekazywanie wszystkich atrybutów do update . Na przykład, jeśli wywołano @article.update(title: "Nowy tytuł"), Railsy zaktualizowałyby tylko atrybut tytułu, pozostawiając wszystkie inne atrybuty nietknięte.

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

Tytuł	Tekst
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

Dodaj także app/views/articles/show.html.erb do szablonu, aby link „Edytuj” znajdował się również na stronie artykułu. Dodaj następujący tekst na końcu szablonu:

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

A tak wygląda teraz nasza aplikacja:

5.12. Używanie części do czyszczenia powtórzeń w widokach

Nasza strona edycji jest bardzo podobna do nowej strony, w rzeczywistości używają tego samego kodu do wyświetlenia formularza. Usuńmy tę duplikację, używając częściowego widoku. Zgodnie z konwencją, częściowe pliki zaczynają się od podkreślenia.

Utwórz nowy plik app/views/articles/_form.html.erb o następującej treści:

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

Zaktualizujmy teraz widok app/views/articles/new.html.erb, aby używał tej części, całkowicie ją przepisując:

nowy artykuł

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

To samo dotyczy widoku app/views/articles/edit.html.erb:

Edytuj artykuł

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

5.13. Usuwanie artykułów

Jesteśmy teraz gotowi do omówienia części „D” CRUD, usuwania z bazy danych. Zgodnie z konwencją REST ścieżka usuwania artykułów z danych wyjściowych tras kolejowych jest następująca:

USUŃ /artykuły/:id(.:format)artykuły#zniszcz

Metoda routingu usuwania musi być używana w przypadku tras, które niszczą zasoby. W przypadku pozostawienia normalnej trasy pobierania możliwe byłoby wygenerowanie następujących złośliwych adresów URL:

spójrz na tego kota!

Używamy metody delete do niszczenia zasobów, a ta trasa jest powiązana z akcją zniszczenia w app/controllers/articles_controller.rb , która jeszcze nie istnieje. Metoda zniszczenia jest zwykle ostatnią akcją CRUD w kontrolerze i podobnie jak wszystkie publiczne akcje CRUD, musi być umieszczona przed wszelkimi metodami prywatnymi lub chronionymi. Dodajmy to:

Def destroy @artykuł = art.find(params[:id]) @artykuł.destroy redirect_to article_path end

Pełny ArticlesController w app/controllers/articles_controller.rb powinien teraz wyglądać tak:

Kontroler artykułów klasy< 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

Możesz wywoływać niszczyciel na obiektach Active Record, kiedy chcesz usunąć je z bazy danych. Zauważ, że nie musimy dodawać widoku dla tej akcji, ponieważ przekierowujemy do akcji index.

Wyświetlanie artykułów

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

Tytuł	Tekst
<%= 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?" } %>

Tutaj używamy link_to w inny sposób. Jako drugi argument przekazujemy nazwaną trasę, a jako drugi argument opcje. Opcje metody: :delete i data: (confirm: „Czy na pewno?”) są używane jako atrybuty html5, więc po kliknięciu łącza Railsy najpierw pokażą użytkownikowi okno dialogowe potwierdzenia, a następnie wyślą łącze za pomocą metody usuwania . Odbywa się to za pomocą pliku JavaScript rails-ujs, który jest automatycznie dołączany do układu aplikacji (app/views/layouts/application.html.erb) podczas generowania aplikacji. Bez tego pliku okno dialogowe potwierdzenia nie zostanie wyświetlone.

Gratulacje, teraz możesz tworzyć, przeglądać wszystkie i indywidualnie, aktualizować i usuwać artykuły.

Dodanie drugiego modelu

Czas dodać drugi model do aplikacji. Drugi model będzie obsługiwał komentarze do artykułów.

6.1. Generowanie modelu

Zamierzamy użyć tego samego generatora, którego używaliśmy wcześniej przy tworzeniu modelu Artykułu. Tym razem stworzymy model komentarza zawierający link do artykułu. Uruchom następujące polecenie w terminalu:

$ Rails generuje model Komentarz komentujący:string treść:tekst artykuł:referencje

To polecenie generuje cztery pliki:

Najpierw spójrzmy na app/models/comment.rb:

komentarz klasowy< ApplicationRecord belongs_to:article end

Jest to bardzo podobne do modelu artykułu, który widzieliśmy wcześniej. Różnica polega na tym, że wiersz należy do:artykuł , który ustawia połączenie aktywny zapis. O połączeniach dowiesz się w dalszej części poradnika.

Słowo kluczowe (:references) używane w poleceniu bash jest specjalnym typem danych dla modeli. Tworzy nową kolumnę w twojej bazie danych z nazwą wyrenderowanego modelu z dołączonym _id, która może zawierać wartości liczbowe. Aby lepiej zrozumieć, przeanalizuj plik db/schema.rb po zakończeniu migracji.

Oprócz modelu Railsy wykonały również migrację w celu stworzenia odpowiedniej tabeli bazy danych:

Utwórz komentarze klasy< 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

Linia t.references tworzy kolumnę numeryczną o nazwie art_id , indeks na niej i ograniczenie klucza obcego wskazujące na kolumnę id tabeli artykułów. Następnie uruchamiamy migrację:

$ Rails db:migracja

Railsy są wystarczająco inteligentne, aby uruchamiać tylko te migracje, które nie zostały jeszcze uruchomione w bieżącej bazie danych, w naszym przypadku zobaczysz:

Utwórz komentarze: migracja ============================================= = = -- create_table(:comments) -> 0.0115s == CreateComments: migrated (0.0119s) =========================== == ==========

6.2. Łączenie modeli

Łącza Active Record umożliwiają łatwe zadeklarowanie relacji między dwoma modelami. W przypadku komentarzy i artykułów relację można opisać w następujący sposób:

• Każdy komentarz należy do jednego artykułu.
• Jeden artykuł może mieć wiele komentarzy.

W rzeczywistości jest to bardzo zbliżone do składni używanej przez Railsy do deklarowania tej relacji. Widziałeś już linijkę kodu w modelu Comment (app/models/comment.rb), która sprawia, że ​​każdy komentarz należy do artykułu:

komentarz klasowy< ApplicationRecord belongs_to:article end

Musisz edytować app/models/article.rb, aby dodać drugą stronę linku:

artykuł klasowy< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Te dwa ogłoszenia są automatycznie udostępniane duża liczba możliwości. Na przykład, jeśli masz zmienną instancji @article zawierającą artykuł, możesz pobrać wszystkie komentarze należące do tego artykułu w tablicy, wywołując @article.comments .

6.3. Dodanie trasy dla komentarzy

Podobnie jak w przypadku kontrolera powitalnego, musimy dodać trasę, aby Rails wiedział, pod który adres chcemy się udać, aby zobaczyć komentarze. Ponownie otwórz plik config/routes.rb i edytuj go w następujący sposób:

Zasoby:artykuły do ​​zasobów:Komentarze koniec

Spowoduje to utworzenie komentarzy takich jak zagnieżdżony zasób w artykułach. To druga strona uchwycenia hierarchicznej relacji między artykułami a komentarzami.

6.4. Wygeneruj kontroler

Mając gotowy model, zajmijmy się stworzeniem odpowiedniego kontrolera. Ponownie użyjemy tego samego generatora, którego używaliśmy wcześniej:

$ szyny generują kontroler

Zostaną utworzone cztery pliki i pusty katalog:

Tak jak w przypadku każdego innego bloga, nasi czytelnicy utworzą swoje komentarze natychmiast po przeczytaniu artykułu, a po dodaniu komentarza zostaną przekierowani z powrotem na stronę wyświetlania artykułu i zobaczą, że ich komentarz został już odzwierciedlony. Pod tym względem nasz CommentsController służy jako środek do tworzenia komentarzy i usuwania spamu, jeśli taki istnieje.

Najpierw rozszerzymy szablon pokazu artykułów (app/views/articles/show.html.erb), aby umożliwić nam dodanie nowego komentarza:

Tytuł: <%= @article.title %>

tekst: <%= @article.text %>

Dodaj komentarz:

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

Spowoduje to dodanie formularza do strony wyświetlania artykułu, który tworzy nowy komentarz po wywołaniu akcji tworzenia na kontrolerze CommentsController. Tutaj wywołanie form_with używa tablicy, która utworzy zagnieżdżoną trasę, taką jak /articles/1/comments .

Napiszmy create w app/controllers/comments_controller.rb:

Kontroler komentarzy klasy< 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

Jest to nieco bardziej skomplikowane niż to, co widziałeś w kontrolerze artykułów. Jest to efekt uboczny skonfigurowanego załącznika. Każda prośba o komentarz śledzi artykuł, do którego komentarz jest dołączony, więc najpierw rozwiązujemy pobieranie artykułu, wywołując funkcję find w modelu Artykuł.

Ponadto kod korzysta z niektórych metod dostępnych dla relacji. Używamy metody create na @article.comments, aby utworzyć i zapisać komentarz. Spowoduje to automatyczne powiązanie komentarza, tak aby należał do konkretnego artykułu.

Po utworzeniu nowego komentarza przenosimy użytkownika z powrotem do oryginalnego artykułu za pomocą pomocnika article_path(@article). Jak widzieliśmy, wywołuje ona akcję show na kontrolerze ArticlesController , który z kolei renderuje szablon show.html.erb. W tym miejscu chcemy wyświetlać komentarze, więc dodajmy następujące elementy do app/views/articles/show.html.erb .

Tytuł: <%= @article.title %>

tekst: <%= @article.text %>

Uwagi

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

komentator: <%= comment.commenter %>

Komentarz: <%= comment.body %>

<% end %>

Dodaj komentarz:

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

Możesz teraz dodawać artykuły i komentarze do swojego bloga i wyświetlać je w odpowiednich miejscach.

Refaktoryzacja

Skoro artykuły i komentarze już działają, przyjrzyjmy się szablonowi app/views/articles/show.html.erb. Stał się długi i niewygodny. Użyjmy częściowych, aby to rozładować.

7.1. Renderowanie kolekcji częściowych

Najpierw zróbmy częściowy komentarz, który pokazuje wszystkie komentarze do artykułu. Utwórz plik app/views/comments/_comment.html.erb i umieść w nim:

komentator: <%= comment.commenter %>

Komentarz: <%= comment.body %>

Następnie możesz zmienić app/views/articles/show.html.erb w następujący sposób:

Tytuł: <%= @article.title %>

tekst: <%= @article.text %>

Uwagi

<%= render @article.comments %>

Dodaj komentarz:

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

Spowoduje to teraz renderowanie fragmentu pliku app/views/comments/_comment.html.erb dla każdego komentarza w kolekcji @article.comments. Ponieważ metoda render iteruje po kolekcji @article.comments, przypisuje każdy komentarz do zmiennej lokalnej o nazwie, takiej jak częściowa, w naszym przypadku comment , która jest dostępna w częściowej do renderowania.

7.2. Renderowanie formularza w części

Przenieśmy też nową sekcję komentarzy do naszej częściowej. Ponownie utwórz plik app/views/comments/_form.html.erb zawierający:

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

Następnie zmień app/views/articles/show.html.erb w ten sposób:

Tytuł: <%= @article.title %>

tekst: <%= @article.text %>

Uwagi

<%= render @article.comments %>

Dodaj komentarz:

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

Drugi render po prostu definiuje szablon części, którą chcemy renderować, komentarze/formularz . Railsy są wystarczająco inteligentne, aby zastąpić podkreślenie w tym wierszu i zrozumieć, że chciałeś wyrenderować plik _form.html.erb w katalogu app/views/comments.

Obiekt @article jest dostępny we wszystkich częściach renderowanych w widoku, ponieważ zdefiniowaliśmy go jako zmienną instancji.

Usuwanie komentarzy

Kolejną ważną cechą bloga jest możliwość usuwania spamu. Aby to zrobić, musimy wstawić jakiś link w widoku i akcję zniszczenia w CommentsController .

komentator: <%= comment.commenter %>

Komentarz: <%= comment.body %>

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

Naciśnięcie tego nowy link„Zniszcz komentarz” uruchomi DELETE /articles/:article_id/comments/:id na naszym kontrolerze komentarzy, który zostanie następnie użyty do znalezienia komentarza, który chcemy usunąć, więc dodajmy akcję zniszczenia do naszego kontrolera (app/controllers/comments_controller rb) :

Kontroler komentarzy klasy< 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

Akcja zniszczenia znajdzie artykuł, który przeglądamy, znajdzie komentarz w kolekcji @article.comments, a następnie usunie go z bazy danych i przeniesie nas z powrotem do widoku artykułu.

8.1. Usuwanie powiązanych obiektów

Jeśli usuniesz artykuł, powiązane z nim komentarze również muszą zostać usunięte, w przeciwnym razie zajmą tylko miejsce w bazie danych. Railsy pozwalają na użycie zależnej opcji łącza, aby to osiągnąć. Zmodyfikuj model artykułu, app/models/article.rb w następujący sposób:

artykuł klasowy< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Bezpieczeństwo

9.1. Uwierzytelnianie podstawowe

Jeśli publikujesz swojego bloga online, każdy może dodawać, edytować i usuwać artykuły oraz usuwać komentarze.

Railsy zapewniają podstawowy system uwierzytelniania HTTP, który dobrze sprawdza się w takiej sytuacji.

W ArticlesController potrzebujemy sposobu na zablokowanie dostępu do różnych akcji, jeśli użytkownik nie jest uwierzytelniony. Tutaj możemy użyć metody Rails http_basic_authenticate_with, aby umożliwić dostęp do wymaganych akcji, jeśli metoda na to pozwala.

Aby korzystać z systemu uwierzytelniania, zdefiniujemy go na górze naszego ArticlesController w app/controllers/articles_controller.rb . W naszym przypadku chcemy, aby użytkownik był uwierzytelniany dla każdej akcji z wyjątkiem index i show , więc zapiszemy to w ten sposób:

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

Chcemy również, aby tylko uwierzytelnieni użytkownicy mogli usuwać komentarze, więc w CommentsController (app/controllers/comments_controller.rb) napiszemy:

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

Teraz, jeśli spróbujesz utworzyć nowy artykuł, napotkasz wyzwanie podstawowego uwierzytelnienia HTTP:

Inne metody uwierzytelniania są również dostępne dla aplikacji Railsowych. Dwa popularne dodatki do Railsów to między innymi Devise i Authlogic.

9.2. Inne przemyślenia dotyczące bezpieczeństwa

Bezpieczeństwo, zwłaszcza w aplikacjach webowych, to obszerna i szczegółowa dziedzina. Bezpieczeństwo Twojej aplikacji Rails jest omówione bardziej szczegółowo w przewodniku Bezpieczeństwo aplikacji Rails Najłatwiejszym sposobem pracy z Railsami jest przechowywanie wszystkich danych zewnętrznych w UTF-8. Jeśli nie, biblioteki Ruby i Rails często będą w stanie przekonwertować dane natywne na UTF-8, ale to nie zawsze działa niezawodnie, więc najlepiej jest upewnić się, że wszystkie dane zewnętrzne to UTF-8.

Jeśli popełnisz błąd w tym obszarze, najczęstszym objawem jest czarny romb ze znakiem zapytania w środku, który pojawia się w przeglądarce. Innym częstym objawem są znaki takie jak „ü” pojawiające się zamiast „ü”. Rails podejmuje szereg wewnętrznych kroków w celu złagodzenia typowych przypadków problemów, które mogą być automatycznie wykrywane i naprawiane. Jeśli jednak istnieją dane zewnętrzne, które nie są przechowywane w UTF-8, może to prowadzić do tego rodzaju problemów, których Railsy nie mogą automatycznie wykryć i naprawić.

Dwa najczęstsze źródła danych, które nie są w UTF-8, to:

• Twój Edytor tekstu: Większość edytorów tekstu (takich jak TextMate) domyślnie zapisuje pliki w formacie UTF-8. Jeśli Twój edytor tekstu tego nie robi, może to spowodować, że znaki specjalne wpisane w szablonach (takie jak é) będą wyświetlane w przeglądarce jako znak zapytania w kształcie rombu. Dotyczy to również plików tłumaczeń i18N. Większość edytorów, które nie używają standardowego UTF-8 (na przykład niektóre wersje programu Dreamweaver) oferuje sposób na zmianę domyślnych ustawień na UTF-8. Zrób tak.
• Twoja baza danych: Railsy domyślnie konwertują dane z Twojej bazy danych do UTF-8 na granicy. Jeśli jednak baza danych nie używa wewnętrznie kodowania UTF-8, może nie być w stanie przechowywać wszystkich znaków wpisywanych przez użytkownika. Na przykład, jeśli baza danych używa wewnętrznie języka Latin-1, a użytkownik wprowadzi znaki rosyjskie, hebrajskie lub japońskie, dane zostaną utracone, gdy tylko zostaną wprowadzone do bazy danych. Jeśli to możliwe, użyj UTF-8 jako pamięci wewnętrznej w swojej bazie danych.

Autor został zachęcony do napisania tego tekstu poprzez przestudiowanie szeregu materiałów znalezionych w Global Web, które równie dobrze można by oznaczyć tym samym nagłówkiem/znacznikiem: Jak nauczyłem się Rubiego(lub Ruby on Rails, PHP, JS, C++ itp.) przez trzy dni.

Cóż, lub podobne. Autorka z kolei od razu przypomniała sobie (niepohamowane skojarzenia) szereg anegdot, które znów łączy wspólny temat, jakim jest ocena działań, które można wykonać głupio… język rosyjski jest potężny i niesamowicie aforystyczny, ale niestety nie wydaje się możliwe przytoczenie tutaj tych arcydzieł; w związku z tym nie pozostaje nic innego, jak zwrócić uwagę czytelnika na napisaną przez siebie wersję doki z cyklu Jak dobrze się bawić i stosunkowo szybko nauczyć się pracować w Ruby on Rails.

Działający przykład kodu opisanego w artykule, między innymi Rails Examples - zawsze można znaleźć na testowym blogu autora pod adresem herokuapp.com, zapraszamy.

Technika jest prosta, a autor wcale nie pretenduje do miana pioniera: trzeba, żeby była ciekawa, a na efekty nie trzeba było długo czekać. Nie zaszkodzi spróbować zagrać na własnych słabościach, czasem nawet próżność może być korzystna dla sprawy; wyniki prac rozwojowych powinny być takie, aby można je było z dumą prezentować czytelnikom, przyjaciołom i współpracownikom w sieci, umieszczać gdzieś na Heroku Lub Amazonka, także - abyście mogli do nich wracać wielokrotnie, przebudowując i ulepszając, fora i StackOwerflow, aby pomóc nam wszystkim. Więc mówię, dlaczego nie napisać, na początek, na swoim blogu Rubin na szynach?

Proponuję zacząć od doskonałych doków Getting Started with Rails lub jego rosyjskojęzycznej adaptacji Rails dla początkujących, a także Build a Blog with Ruby on Rails, aby wspomóc się także materiałami tego bloga, do których linki są łatwo zlokalizowane w lewym pasku bocznym . A potem - wszystko, potem magia, na początku wszystko jest pomalowane jak w zegarku, otwórz konsolę - i śmiało... autor uważa za swój obowiązek dokonanie tylko kilku wyjaśnień i zaleceń technicznych mających na celu ułatwienie adeptowi szukaj i zdobywaj Jasną Stronę Mocy, i nigdy więcej Togo. To tylko twoja walka, śmiało i wróć z wygraną.

Więc. Krok po kroku pierwszej instrukcji jest dobrze skalibrowany i nie sprawi ci, mam nadzieję, kłopotów; wszystko, czego wymaga się od Ciebie, to uważność, skrupulatne powtarzanie szczegółowo skomentowanych kroków ... a za godzinę Twój pierwszy blog jest gotowy, możesz zrobić sobie przerwę i przejść do drugiego, nieco ciekawszego. I tu może się okazać, że przyda się kilka pożegnalnych słów, do których teraz przejdziemy.

Zacznijmy od stwierdzenia, że ​​te metody mogą (alternatywnie) wyglądać jak poniżej, ale w żaden sposób nie przypominają oryginału:

app/controllers/posts_controller.rb

# Akcja aktualizacji aktualizuje post o nowe informacje def update if @post.update_attributes(post_params) flash[:notice] = "Pomyślnie zaktualizowano wpis!" redirect_to posts_path else flash[:alert] = "Błąd aktualizacji posta!" render:edit end end # Akcja show renderuje indywidualny post po pobraniu identyfikatora def show end # Akcja niszczenia trwale usuwa wpis z bazy danych def destroy @post = Post.find(params[:id]) if @post .destroy flash[:notice] = "Pomyślnie usunięto wpis!" redirect_to posts_path else flash[:alert] = "Błąd aktualizacji posta!" koniec koniec

A jednak spróbuj w ten i inny sposób, czemu nie. Idziemy dalej.

Drugi blog, choć bardziej rozbudowany (dodany edytor artykułów Edytor CK I urządzenie, elastyczne narzędzie uwierzytelniające dla aplikacji Railsowych), z jakiegoś powodu nie zezwala na komentarze w oryginale. Ten brak będziesz musiał nadrobić sam: postępuj analogicznie do opisu powstania pierwszego bloga, wymagane będą tylko bardzo drobne zmiany: po prostu wpisz zamiast artykuł I artykuły pierwszy blog, jaki będziesz mieć post I posty w drugim blogu, to wszystko, w rzeczywistości, różnica. Bądź ostrożny, a wszystko się ułoży.

Recaptcha będziesz także musiał sam linkować do komentarzy: tak, tak, to nie jest Joomla dla ciebie, przyzwyczaj się. Jednak tytaniczne wysiłki nie są wymagane, proces połączenia Recaptcha szczegółowo opisane w artykule Włączenie Recaptcha w aplikacji Rails. Ponadto dostosowywanie nie jest zbyteczne urządzenie w taki sposób, aby blog działał (przynajmniej na początku!) w trybie pojedynczego użytkownika, pozwalając wielu jego czytelnikom na tryb TYLKO DO ODCZYTU, innymi słowy, na początek zabronimy rejestracji nowych użytkowników. W Internecie jest wiele różnych przepisów, jak to zrobić, ale moim zdaniem najbardziej kompetentny hack tego rodzaju znajduje się w projekcie Wiki, w materiale zatytułowanym How To: Set up devise as a single user system . Mianowicie tworzymy nowy kontroler:

app/controllers/registrations_controller.rb:

Kontroler rejestracji klas< Devise::RegistrationsController before_action:one_admin_registered?, only: [:new, :create] protected def one_admin_registered? if ((Admin.count == 1) & (admin_signed_in?)) redirect_to root_path elsif Admin.count == 1 redirect_to new_admin_session_path end end end

następnie nadpisujemy to w route.rb i to wszystko:

#devise_for:administratorzy devise_for:administratorzy, kontrolerzy: (rejestracje: "rejestracje")

CKEDITOR.editorConfig = function(config) ( // config.enterMode = 2; // wyłączone

Całkowicie config.enterMode = CKEDITOR.ENTER_BR // naciśnięcie klawisza ENTER
config.shiftEnterMode = CKEDITOR.ENTER_P; //naciśnięcie klawiszy SHIFT + ENTER KLAWISZY

Config.autoParagraph = fałsz; // zatrzymuje automatyczne wstawianie

w skupieniu);

Może na początek to naprawdę wszystko… cholera, prawie zapomniałem o najważniejszej rzeczy. Jeśli zamierzasz wdrożyć swój nowy blog na Heroku- dodaj te trzy linie do

config/aplikacja.rb

Config.assets.precompile += Ckeditor.assets config.assets.precompile += %w(ckeditor/*) config.autoload_paths += %W(#(config.root)/app/models/ckeditor)

W przeciwnym razie Edytor CK odmawia pracy dla ciebie w nowym miejscu.

Ruby to potężny i popularny język programowania. Oprócz swojej popularności bazuje na nim dobrze znany framework, który pozwala na tworzenie fajnych i dynamicznych stron internetowych o różnej tematyce. Jeśli spojrzeć na ranking TIOBE, to język ten znajduje się wśród dwudziestu najpopularniejszych języków na świecie.

Język pojawił się w 1995 roku i jest uważany za młody język w porównaniu do C lub C++, które pojawiły się odpowiednio w 1972 i 1983 roku. Język ma szereg zalet i specyficznych cech, które są zaimplementowane wyłącznie w nim, jeśli porównamy inne popularne języki programowania.

Plan kursu

Podczas kursu wideo nauczysz się języka Ruby bez korzystania z dodatkowych frameworków. Dodatkowe kursy dot rubin można znaleźć na .

Podczas kursu nauczymy się instalować i pracować z językiem, poznamy składnię Rubin(zmienne, pętle, instrukcje warunkowe), a także rzeczy bardziej złożone: OOP, praca z plikami, wyjątki, metody i wiele innych tematów.

Instalowanie Rubiego w systemie Windows

Aby zainstalować Ruby w systemie Windows, użyj Instalator Ruby, który można pobrać z oficjalnej strony pod tym linkiem. Pobierać Ostatnia wersja i zainstaluj go jak normalny program. Po zakończeniu instalacji zobaczysz podobne okno:

W tym oknie upewnij się, że pole wyboru jest zaznaczone, a następnie otworzy się inna aplikacja do instalacji rubin do systemu.

W oknie, które się otworzy wpisujemy kolejno 1 i wciskamy Enter, po odczekaniu na zakończenie instalacji wciskamy 2 i Enter i na koniec wykonujemy trzecie polecenie naciskając 3 i Enter.

Instalowanie Rubiego na komputerze Mac

Na komputerze Mac Ruby jest instalowany domyślnie, więc nie musisz robić nic więcej. Możesz sprawdzić wersję językową w terminalu za pomocą następującego polecenia:

Jeśli wersja jest nieaktualna, możesz pobrać nową. Najpierw musisz pobrać menedżera wersji Ruby. Odbywa się to za pomocą terminala za pomocą polecenia:

Curl -L https://get.rvm.io | bash -s stabilny

Po zainstalowaniu menedżera uruchom ponownie terminal. Uruchom następujące polecenie:

Lista RVM znana

Po ponownym uruchomieniu możesz zainstalować dowolną wersję. W naszym przypadku zainstalowano wersję 2.4.2:

rvm zainstaluj ruby-2.4.2

Na koniec możesz ponownie sprawdzić wersję, a jeśli nadal jest stara, po prostu ustaw jako domyślną nową wersję.

Jeden z pierwszych i najbardziej kompleksowych samouczków Rails w sieci. Główną zaletą jest szczegółowe omówienie najpotrzebniejszych zagadnień, regularne aktualizacje i bezpłatne treści.

To prawda, że ​​​​zasób jest całkowicie w języku angielskim. I ważne jest, aby zrozumieć, że jest to zbudowane w formie książki - musisz sam rozgryźć wszystkie kwestie. Z tego powodu nie można przewidzieć czasu trwania i złożoności szkolenia.

2. Transmisje kolejowe

Kolejny dobrze znany w Internecie zasób szkoleniowy. Wychowało się na nim więcej niż jedno pokolenie programistów Rails. Również w języku angielskim.

Nie jest zbudowany jako holistyczne szkolenie, ale jako seria screencastów - krótkich lekcji na określony temat. Istnieje wiele lekcji, można znaleźć prawie każdy temat.

Niestety, projekt przestał być aktualizowany w 2013 roku.

3. Szyny dla zombie

Świetne wprowadzenie do szyn dla początkujących w grze w stylu questów z klimatem zombie. Jest bardzo popularny wśród zupełnie początkujących.

Wygodne jest to, że nie trzeba niczego instalować na komputerze. Wszystkie zagadki są rozwiązywane w przeglądarce. Krok po kroku przechodzisz przez grę i zaczynasz rozumieć podstawy Ruby on Rails.

Jeśli w ogóle nie rozumiesz programowania, to twój wybór. Na kursie nie ma skomplikowanych tematów, nic nie odwraca uwagi od podstaw. Po angielsku.

3. Udemy

Duży zbiór kursów wideo. Wśród nich jest wiele na rubinach i rubinach na szynach. Nie ma sensu podawać konkretnych linków - wybierz według własnego gustu według ceny lub popularności.

Format Udemy obejmuje dość krótkie kursy z naciskiem na lekcje wideo. Nie oczekuj od nauczycieli poważnej pracy domowej ani szybkiego wsparcia.

4. Bursa rubinowa

Potężny, krótki kurs podstaw programowania w Railsach. Doświadczeni lektorzy, dobry program.

Na kursie pożądana jest osobista obecność studenta i odbywa się to tylko w dużych miastach Ukrainy.

5. Rozwój Ruby on Rails od Evil Marsians

Trzydniowe intensywne szkolenie jednego z najbardziej doświadczonych zespołów Ruby on Rails w Rosji.

Rzadko zrobione. Jest drogi (sądząc po recenzjach, warto). Wymaga osobistej obecności. Odpowiedni tylko dla zaawansowanych programistów, nie ma tam nic do roboty dla początkujących.

6. Ruby on Rails Online Intensive od Good Programmer

Świeży projekt zespołu znanego na Youtube z kursów Ruby dla początkujących.

Ten 3-miesięczny intensywny program jest przeznaczony dla całkowicie początkujących i obiecuje, że staniesz się młodszym programistą z portfolio nie więcej niż 12 inteligentnych aplikacji.

Kurs składa się z lekcji wideo, zadań praktycznych, wsparcia nauczyciela, regularnych webinariów.

Sądząc po kanał Youtube i komentarze użytkowników - ci faceci wiedzą, co robią i nie będą się nimi nudzić.

Główną zaletą każdego projektanta stron internetowych jest umiejętność zrozumienia – a nawet zorganizowania – tego, co dzieje się „za kulisami”.

Przynajmniej powinieneś wziąć kilka lekcji programowania. Nie mówię tu o językach frontendowych typu HTML i CSS – pewnie znasz już sporo tych rzeczy. Mówię o rzeczach z tyłu.

Jeśli wiesz, jak położyć fundament, możesz lepiej zrozumieć, jak zaprojektować resztę witryny. Faktem jest, że nauka kodowania sprawi, że będziesz bardziej erudycyjnym projektantem. Poza tym, kto nie chciałby zatrudnić projektanta, który wie wszystko, od projektowania po tworzenie stron internetowych?

Sztuczka polega na tym, aby wybrać miejsce do rozpoczęcia. Nauka programowania może być trudnym procesem, zwłaszcza jeśli wybierzesz jeden z najbardziej złożone języki jak C++ czy PHP.

Więc od czego najlepiej zacząć? Odpowiedź jest tylko jedna: Ruby on Rails to jeden z najlepszych języków programowania i frameworków do nauki podstaw projektowania.

Dlaczego Ruby to najlepszy wybór?

Dla początkujących Ruby jest jednym z najłatwiejszych języków do nauczenia się, zwłaszcza jeśli masz pewne doświadczenie w HTML lub CSS, które ma większość projektantów.

Jednym z pierwszych programów, które stworzysz, gdy zaczniesz uczyć się języka, jest niesławny „Hello World!”, który polega na wydrukowaniu tych słów na ekranie.

W językach takich jak C++ wyświetlenie tych dwóch słów może wymagać od pięciu do siedmiu linii kodu. Ale jeśli użyjesz Rubiego, będzie tylko jedna linia i jedno polecenie.

Umieszcza „Witaj, świecie!”

To wszystko! To wszystko, czego potrzebujesz, aby wydrukować słowa „Witaj, świecie!” na ekranie. Całkiem łatwe, prawda?

Ruby on Rails jest również bardzo suchym językiem. Będąc jedną z zasad rozwoju, DRY (suchy) oznacza „Don't Repeat Yourself” (Nie powtarzaj się!) – czyli nie programuj ponownie elementu, gdy możesz użyć tego, który już stworzyłeś. To sprawia, że ​​Ruby jest bardzo lekkim i powszechnie używanym językiem programowania do programowania, ponieważ ma na celu szybkie i wydajne wykonanie projektu.

Ruby czy Railsy?

Ruby to język programowania. Rails to framework, który wykorzystuje Ruby do wykonania zadania. Framework Ruby on Rails to zbiór prefabrykowanego lub wstępnie napisanego kodu, który pomaga przyspieszyć proces tworzenia nowych projektów. Początkowo powstał w celu rozwoju narzędzia do zarządzania projektami Basecamp. Oprócz Basecamp istnieją inne popularne aplikacje internetowe zbudowane w Railsach, takie jak 500px, ThemeForest i MyFitnessPal.

Kiedy już zrozumiesz, jak pracować z językiem Ruby i nauczysz się działać w środowisku Ruby On Rails, możesz zacząć tworzyć aplikacje internetowe.

Rubin - u szczytu popularności!

Dzięki eksplozji popularności urządzenia mobilne i technologii, która jest zawsze w kontakcie, Ruby jest obecnie niezwykle popularny. I tak zapewne będzie nadal. Indeks TIOBE plasuje Ruby na 13. miejscu wśród najpopularniejszych języków programowania. Zgodnie z nowymi trendami, według Indeed.com, Ruby również cieszy się zaskakująco dużym zainteresowaniem.

Indeks TIOBE

Tak czy inaczej, niezależnie od tego, czy wybierzesz popyt, czy popularność, Ruby jest dość popularny. To czyni go jednym z najlepsze miejsca zacznijmy od tego, ponieważ kiedy opanujesz język, możesz dość szybko znaleźć pracę. I to zanim zaczniesz uczyć się innego języka, aby poszerzyć swoje umiejętności.

Ruby ma mocne oparcie!

Niektóre inne języki były po naszej stronie bardziej, to prawda, ale mimo to wsparcie i dokumentacja bledną w porównaniu z tym, co jest dostępne dla Ruby. W innych językach również brakuje spójności społeczności wokół jednego mocno wspieranego frameworka.

Dzięki frameworkowi Ruby On Rails istnieje już mnóstwo gotowego kodu, który możesz wykorzystać we własnych projektach. Ruby Gems, biblioteka frameworka Ruby, ma do wyboru ponad 600 000 bibliotek.

Za każdym razem, gdy uczysz się czegoś nowego, potrzebujesz dużo dokumentacji i wsparcia. Istnieje mnóstwo miejsc, w których można znaleźć samouczki, samouczki, przewodniki, a nawet fora pytań i odpowiedzi. Jeśli napotkasz konkretny problem, proste wyszukiwanie w Internecie prawdopodobnie go rozwiąże. To jest ważne.

Prosta dokumentacja i łatwy dostęp do wsparcia są niezbędne, gdy uczysz się nowego języka — kiedy faktycznie uczysz się czegoś nowego.

Ruby „pozwala” na większą kontrolę nad projektem

Jeśli jesteś tylko projektantem stron internetowych, tworzenie strony internetowej może być długim i skomplikowanym procesem. Kiedy siadasz do pracy z programistą i omawiasz niezbędny back-end dla swojej witryny, często musisz poświęcić front-end, aby wszystko działało poprawnie.

Ostatecznie może to prowadzić do produktu, który wygląda zupełnie inaczej niż Twoja pierwotna wizja. Programistę może to nie obchodzić, ale prawdopodobnie będzie to dla ciebie problematyczne.

Nie napotkasz problemów tego rodzaju, jeśli sam zaprogramujesz. Nie musisz polegać na innych, aby uzyskać gotowy projekt, a będziesz mieć znacznie lepsze zrozumienie tego, co można osiągnąć w zakresie rozwoju. Z pewnością był raz lub dwa, kiedy cele Twojego projektu były zbyt wysokie dla jednego programisty lub zespołu programistów? Z drugiej strony, kiedy uczysz się języka takiego jak Ruby, możesz cieszyć się łatwością zrozumienia potrzeb i możliwości.

Zasadniczo Ruby jest przeznaczony do stosowania w aplikacjach internetowych i tworzeniu stron internetowych, więc jest to idealne miejsce dla początkujących projektantów stron internetowych. Kiedy już zrozumiesz język i nauczysz się korzystać z frameworka Ruby on Rails, będziesz mieć znacznie większą kontrolę nad swoimi projektami.

Gdzie uczyć się Rubiego?

Bardzo Najlepszym sposobem uczyć się języka to zanurzyć się w nim i pracować z nim. Istnieje wiele przewodników i samouczków, do których możesz się odnieść. Jeśli masz rozwiniętą pamięć wzrokową i lepiej rozumiesz dzięki prezentacjom wizualnym, wejdź na YouTube - jest duży wybór filmów edukacyjnych.

Jeśli chcesz uczyć się w sposób tradycyjny, jak w klasie, możesz uczyć się na stronach internetowych do nauki programowania. Nie musisz iść na uniwersytet ani do college'u, aby zdobyć wykształcenie zawodowe.

Jednym z moich ulubionych zasobów — i całkowicie darmowych — do nauki Railsów jest samouczek Michaela Hartle'a. Poprowadzi Cię od prostego do złożonego projektu we własnym tempie i możesz zacząć od początku bez żadnej wiedzy na temat Ruby on Rails.

Bez względu na to, którą ścieżkę nauki wybierzesz, pamiętaj, że tylko praktyka czyni mistrza. Ustal osobiste cele, aby każdego dnia poświęcić określoną ilość czasu na pracę z Ruby. Trzymaj się tych celów i bądź wytrwały. Zanim poznasz ten język do końca, będziesz już ekspertem, który potrafi stworzyć fantastyczne projekty.