Routing i podstawy obsługi kontrolerów

W poprzednim module udało nam się zaprojektować model danych, zawierający wszystkie obecne w nim klasy oraz zachodzące pomiędzy nimi relacje.

[info] Jeśli pracujesz na laboratorium, aby rozpocząć realizację kolejnego modułu, musisz wykonać poniższe operacje

• sklonuj repozytorium ze swoim kodem (git clone ŚCIEŻKA_DO_REPOZYTORIUM),

• zainstaluj potrzebne gemy (bundle install --path vendor/bundle),

• dokonaj migracji bazy danych (rails db:migrate)

• uruchom serwer (rails server)

W wypadku aplikacji rails, jeśli korzystamy z tzw. rusztowań (scaffolds), model danych tworzony jest zgodnie z regułą projektowania interfejsów programistycznych w architekturze REST. Na tę chwilę musi wystarczyć nam informacja, że możemy wyświetlić sobie wszystkie ścieżki (URL) dostępne dla klienta naszej aplikacji. Aby je wyświetlić, wystarczy uruchomić zadanie routes.

• rails routes

Na tę chwilę wynikiem wykonania komendy rails routes powinien być ekran podobny do poniższego.

Prefix       Verb   URI Pattern                  Controller#Action
posts        GET    /posts(.:format)             posts#index
             POST   /posts(.:format)             posts#create
new_post     GET    /posts/new(.:format)         posts#new
...
new_student  GET    /students/new(.:format)      students#new
edit_student GET    /students/:id/edit(.:format) students#edit
student      GET    /students/:id(.:format)      students#show
             PATCH  /students/:id(.:format)      students#update
             PUT    /students/:id(.:format)      students#update
             DELETE /students/:id(.:format)      students#destroy

Są to wszystkie możliwe schematy zapytań, które możemy wysłać do naszej aplikacji. Przykładowo, wchodząd pod adres http://localhost:3000/students, możemy zaobserwować gotowy interfejs webowy do obsługi zasobu studenta.

Spróbuj, przeklikując ten interfejs utworzyć w bazie danych dwóch studentów.

Utwórz również:

• dwa kursy (http://localhost:3000/courses),

• dwa tematy (http://localhost:3000/topics),

• oraz dwa posty (http://localhost:3000/posts).

[info] Pamiętaj, że

• Aby utworzyć temat, należy podać identyfikator istniejącego studenta i kursu.

• Aby utworzyć post, należy podać identyfikator istniejącego studenta i tematu.

Poza kontrolerami tworzonymi domyślnie przy scaffoldingu, możemy oczywiście programować też własne. Spróbujmy więc zrobić to dla obsługi głównej strony naszego serwisu (http://localhost:3000/), aby nareszcie zniknęły z niej radośni ludzie i zwierzęta stojący na wycinku kuli ziemskiej.

Rozpoczniemy od dodania wpisu do pliku routes.rb, który przechowuje wszystkie zdefiniowane przez nas ścieżki. W dowolnym jego miejscu utwórzmy wpis wskazujący na domyślną ścieżkę root, opisującą stronę główną, która będzie informować aplikację, że ma wykonywać akcję index, należącą do kontrolera root.

root to: 'static#index'

Po odwiedzeniu strony głównej zobaczymy błąd. Jest to oczywiście błąd na który liczymy, bo po prawdzie programowanie w Ruby on Rails w głównej mierze polega na umiejętności odczytywania komunikatów błędu.

Z aktualnego wynika, zgodnie z prawdą, że w projekcie nie istnieje jeszcze kontroler static. Nie pozostaje więc nam nic innego, niż wygenerować go, używając generatora kontrolerów:

• rails generate controller static

Po przetworzeniu tej komendy, wśród kontrolerów (app/controllers), pojawi się ten, którego potrzebujemy (static_controller.rb). Po odwiedzeniu strony, uzyskamy też nowy błąd.

Mówi on o tym, że w istniejącym już kontolerze, który został wskazany przez plik routingu, nie znajduje się akcja index. Będzie to oczywistą prawdą. Zaspokójmy więc oczekiwania serwera i uzupełnijmy plik kontrolera (app/controllers/static_controller.rb) o taką akcję. Początkowo będzie ona pusta.

class StaticController < ApplicationController
  def index

  end
end

Uzyskamy trzeci, ostatni już błąd.

Mówi on nam o tym, że dla istniejącej akcji (index), istniejącego kontrolera (static_controller), nie istnieje żaden widok. Dokonajmy więc ostatni krok niezbędny dla wyeliminowania błędów i stwórzmy plik app/views/static/index.html.erb, wypełniając go prostą, generyczną treścią. Przykładowo:

<h1>Strona główna</h1>
<p>
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
</p>

Po odwiedzeniu strony po raz kolejny, nareszcie spotkamy się z sukcesem.

Pliki widoków, posiadające rozszerzenie .html.erb pozwalają, poza klasycznymi znacznikami HTML, dodawać wstawki kodu. Istnieją ich dwa rodzaje:

• Domknięte klamrami <% oraz %> — które jedynie wykonują zawarty w nich kod Ruby,

• Domknięte klamrami <%= oraz %> — które wykonują zawarty w nich kod i wyświetlają jego wynik.

Korzystając z drugiego rodzaju wstawki, uzupełnijmy kod strony głównej o poniższą linijkę:

<%= Time.now %>

Na naszej stronie głównej wyświetli się aktualny czas.

Złym podejściem jest jednak pisanie dłuższych fragmentów kodu bezpośrednio w widoku. Odpowiednim miejscem na logikę aplikacji są metody naszych kontrolerów, a widoki mają za zadanie jedynie wyświetlać przygotowane w kontrolerach informacje. Uzupełnijmy więc metodę index kontrolera StaticController o minimum kodu. Przykładowo, deklarację zmiennej.

class StaticController < ApplicationController
  def index
    @some_variable = 123
  end
end

Teraz możemy wczytać ją w widoku.

<h1><%= @some_variable %></h1>

Jak widać, zdefiniowane w akcji kontrolera zmienne są dostępne z poziomu jego widoku.

Rozwińmy odrobinę przykład, korzystając w naszym kontrolerze ze zdefiniowanych w pierwszej części laboratorium modeli. Do zmiennej @students pobierzemy wszystkie dostępne w bazie danych obiekty studentów (Student.all), a do zmiennej @courses, informacje o wszystkich kursach (Course.all).

def index
  @students = Student.all
  @courses = Course.all
end

Spróbujmy wyświetlić nasz zbiór studentów.

<%= @students %>

Nie jest to do końca to, czego mogliśmy się spodziewać. W zmiennej @students nie znajduje się tablica ze wszystkimi studentami, a tak zwana relacja ActiveRecord. Pozwala ona na wygodne iterowanie wszystkich elementów w bazie, na które wskazuje, pobierając jedynie te informacje, których nam potrzeba i dopiero wtedy, kiedy będą nam potrzebne.

<ul>
<% @students.each do |student| %>
  <li><%= student %></li>
<% end %>
</ul>

Otrzymaliśmy listę studentów, gdzie lokalna zmienna student wskazuje na każdy kolejny obiekt z bazy. Rozbudujmy ją tak, aby pokazywać nazwę i indeks studenta.

<ul>
<% @students.each do |student| %>
  <li><%= student.name %> <%= student.index %></li>
<% end %>
</ul>

Na podobnej zasadzie, korzystając z funkcji link_to możemy dodać łącze do widoku studenta.

<ul>
<% @students.each do |student| %>
  <%= link_to student do %>
    <li><%= student.name %> <%= student.index %></li>
  <% end %>
<% end %>
</ul>

Wygląda na to, że nauczyliśmy się operować na widokach.

[info] Aktualny kod

Na koniec każdego modułu znajduje się łącze do pełnej wersji kodu, który powinien być jego wynikiem.

• Wprowadzone zmiany

• Pełen kod