Ror cz. 6 – flash[:notice]

Często w kodzie kontrolera widać użycie flash, np.:

flash[:notice] = "Author saved"

Powoduje to wyświetlenie komunikatu dla użytkownika przy najbliższym wyświetleniu jakiejkolwiek strony. I tylko przy najbliższym, czyli komunikat pokaże się raz.

Użycie flash można dodać jako parametr do redirect_to. Czyli zamiast linii:

flash[:notice] = "Author saved"
redirect_to authors_path

Można napisać w jednej lini:

redirect_to authors_path, notice: "Author saved"

Wyświetlenie komunikatu na stronie, musi być uwzględnione w kodzie widoku. Najlepiej jak mamy to zapisane w: /views/layouts/application.html.erb. Np. tak:

<% if flash[:notice].present? %>
  <div class="alert alert-success">
    <%= flash[:notice] %>
  </div>
<% end %>

Nie jest to najlepszy kawałek do obsługi komunikatów, bo zamiast notice, możemy użyć też alert, czy nawet abc. I tu uwaga, możemy napisać:

flash[:abc] = "message"

Ale w redirect_to, możemy użyć tylko notice i alert. Żeby móc używać nasze abc w redirect_to, trzeba w /controllers/application_controller.rb dodać linię:

add_flash_types(:abc)

Ror cz. 5 – usuwanie

W kontrolerze interesuje nas metoda:

  # DELETE /authors/1
  # DELETE /authors/1.json
  def destroy
    @author.destroy
    respond_to do |format|
      format.html { redirect_to authors_url, notice: 'Author was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

I to właściwie wszystko, bo dla usuwania obiektu, domyślnie nie generuje się nowy widok. Wywołanie usuwania jest pod linkiem, który znajduje się na widoku listy autorów (Ror cz. 3 – kontrolery i widoki)

Najprostszy model mamy za sobą, czas przejść do modeli powiązanych relacją, ale to w kolejnej części.

RoR cz. 4 – dodawanie i edycja

Kontroler

W kontrolerze interesują nas 2 metody dotyczące dodawania nowego autora. Obie wygenerowane automatycznie:

  # GET /authors/new
  def new
    @author = Author.new
  end

Wykonywana przed wyświetleniem formularza.

I druga, wykonywana przy Post:

  # POST /authors
  # POST /authors.json
  def create
    @author = Author.new(author_params)

    respond_to do |format|
      if @author.save
        format.html { redirect_to @author, notice: 'Author was successfully created.' }
        format.json { render :show, status: :created, location: @author }
      else
        format.html { render :new }
        format.json { render json: @author.errors, status: :unprocessable_entity }
      end
    end
  end

Zobaczmy jeszcze metodę prywatną:

  def author_params
    params.require(:author).permit(:name, :surname)
  end

Wskazuje nam ona, które właściwości klasy, są skopiowane z widoku do nowego obiektu. Zapobiega ona „złośliwemu” ustawieniu właściwości ukrytych dla formularza.

Analogicznie, są dwie metody dotyczące edycji:

  # GET /authors/1/edit
  def edit
  end

I druga dla POST:

  # PATCH/PUT /authors/1
  # PATCH/PUT /authors/1.json
  def update
    respond_to do |format|
      if @author.update(author_params)
        format.html { redirect_to @author, notice: 'Author was successfully updated.' }
        format.json { render :show, status: :ok, location: @author }
      else
        format.html { render :edit }
        format.json { render json: @author.errors, status: :unprocessable_entity }
      end
    end
  end

Metoda edit jest pusta, bo mamy w klasie zdefiniowany filtr:

before_action :set_author, only: [:show, :edit, :update, :destroy]

I metodę prywatną:

    # Use callbacks to share common setup or constraints between actions.
    def set_author
      @author = Author.find(params[:id])
    end

Metoda ta jet wywoływana przed każdą metodą wymienioną w filtrze, czyli też przed edit.

Widoki

Automatycznie wygenerowały się widoki i teraz interesują mnie trzy z nich new.html.erb:

<h1>New Author</h1>

<%= render 'form', author: @author %>

<%= link_to 'Back', authors_path %>

Edit.html.erb:

<h1>Editing Author</h1>

<%= render 'form', author: @author %>

<%= link_to 'Show', @author %> |
<%= link_to 'Back', authors_path %>

Bardziej rozbudowany i ciekawy jest _form/html/erb:

<%= form_with(model: author, local: true) do |form| %>
  <% if author.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(author.errors.count, "error") %> prohibited this author from being saved:</h2>

      <ul>
      <% author.errors.full_messages.each do |message| %>
        <li><%= message %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :name %>
    <%= form.text_field :name, id: :author_name %>
  </div>

  <div class="field">
    <%= form.label :surname %>
    <%= form.text_field :surname, id: :author_surname %>
  </div>

  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>

Jest to widok częściowy, umieszczony w osobnym pliku, bo używamy go nie tylko przy dodawaniu nowego obiektu, ale też przy edycji.

Widok częściowy może otrzymać parametry. Np. widok new.html.erb przekazuje zmienną: button_name (napis na przycisku submit):

<h3>New author</h3>
<%= render partial: "form", locals: { button_name: "Save new" } %>

a edit.html.erb na:

<h3>Edit author</h3>
<%= render partial: "form", locals: { button_name: "Save changes" } %>

A widok częściowy wygląda jak poniżej. W przedostatniej linijce widzimy wykorzystanie button_name:

<% if @author.errors.present? %>
    <div class="alert alert-danger">
        <p>Errors:</p>
        <ol>
            <% @author.errors.full_messages.each do |message| %>
            <!--<li><%= message.titleize %></li> -->
            <li><%= message %></li>
            <% end %>
        </ol>
    </div>
<% end %>
<%= form_for @author do |f| %>
<div> 
    <%= f.label :name, "Name" %>
    <%= f.text_field :name , class: "form-control "%>
</div>
<div> 
    <%= f.label :name, "Surname" %>
    <%= f.text_field :surname , class: "form-control "%>
</div>
<%= f.submit button_name, class: "btn btn-primary" %>
<% end %>

Widoki korzystają też teraz z bootstrapa.

Ror cz. 3 – kontrolery i widoki

Potrzebujemy kontroler i widoki, żeby obsłużyć nowy model. Wygenerujmy kontroler:

rails g controller Authors

Ale to jest pusty kontroler bez żadnej akcji.

Możemy wygenerować:

rails g controller Authors index new create

Teraz mamy kontroler ze szkieletem 3 akcji i 3 puste widoki odpowiadające tym akcjom.

Możemy wygenerować cały CRUD:

rails g controller Authors index new create edit update show destroy

Ale możemy wygenerować cały CRUD razem z widokami za jednym zamachem:

rails g scaffold Author name: string surname:string

Teraz mamy ciała metod w kontrolerze, gotowe widoki i dodany wpis do pliku: routes.rb

resources :authors

Co załatwia nam routing adresów. Do routingu wrócę w jednym z kolejnych wpisów.

Index

W kontrolerze, metoda index wygląda tak:

def index
   @authors = Author.all
end

I nie potrzebuję jej zmieniać.

Widok views/authors/index.html.erb po wygenerowaniu:

<p id="notice"><%= notice %></p>

<h1>Authors</h1>

<table>
<thead>
<tr>
<th>Name</th>
<th>Surname</th>
<th colspan="3"></th>
</tr>
</thead>

<tbody>
<% @authors.each do |author| %>
<tr>
<td><%= author.name %></td>
<td><%= author.surname %></td>
<td><%= link_to 'Show', author %></td>
<td><%= link_to 'Edit', edit_author_path(author) %></td>
<td><%= link_to 'Destroy', author, method: :delete, data: { confirm: 'Are you sure?' } %></td>
</tr>
<% end %>
</tbody>
</table>

<br>

<%= link_to 'New Author', new_author_path %>

A zmieniam go na:

<h3>Authors</h3>

<p><%= link_to "New author", new_author_path, class: "btn btn-success" %> </p>

<table class="table table-stripped">
<thead>
<tr>
<th>Name</th>
<th>Surname</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<% @authors.each do |author| %>
<tr>
<td><%= author.name %></td>
<td><%= author.surname %></td>
<td>
<%= link_to "Show", author_path(author), class: "btn btn-default btn-xs" %>
<%= link_to "Edit", edit_author_path(author), class: "btn btn-primary btn-xs" %>
<%= link_to "Delete", author_path(author), method: :delete, class: "btn btn-danger btn-xs", data: { confirm: "Are you sure?" } %>
</td>
</tr>
<% end %>
</tbody>
</table>

Czyli korzystam z bootstrapa, a link tworzenia nowego autora przeniosłem na górę. Usunąłem też ’notice”, ale do tego wrócę w kolejnej części, kiedy zajmiemy się dodawaniem/edycją autora

Ruby on Rails krok 2 – pierwszy model

Railsy są oparte o wzorzec MVC. Zaczynamy od M (model)Model w railsach to wzorzec ActiveRecord. Nie jestem fanem tego rozwiązania, ale na razie chcę poznać Railsy z całym dobrodziejstwem inwentarza.
Chcę stworzyć pierwszy model: autor z polami: name i surname.Z poziomu terminala wykonuję komendę:

rails generate model Author name:string surname:string

Zamiast:

rails generate ...

Można używać:

rails g ...

Mamy teraz klasę:

app/models/author.rb

Klasa jest pusta (tylko dziedziczy po ApplicationRecord). Właściwości są generowane na podstawie struktury tabeli.

Gdybyśmy chcieli usunąć model:

rails destroy model author

Migracja bazy danych

Drugi wygenerowany plik, to migracja bazy danych. Zapis zmian w strukturze bazy danych. W naszym przypadku jest to utworzenie nowej tabeli:

authors.db/migrate/data_czas_create_authors.rb

Żeby zmigrować schemat bazy danych, na której pracujemy, trzeba wykonać instrukcję:

rake db:migrate

Migracje można cofać. Ostatnią migrację cofamy za pomocą:

rake db:rollback 

Można cofnąć kilka ostatnich migracji, np: 3

rake db:rollback STEP=3 

Możemy sprawdzić, które migracje zostały wykonane na naszej bazie, a które nie:

 rake db:migrate:status 

Do migracji wrócę jeszcze w jednej z kolejnych części.

Zapis / edycja modelu w bazie z poziomu konsoli

Uruchamiamy konsolę:

rails console 

Wpisujemy:

Author.all
a = Author.new
a.name = “Jacek”
a.surname = “Dukaj”
a.save
Author.all

Zapisaliśmy pierwszego autora do bazy. Teraz czas na wygenerowanie widoków i kontrolerów, ale to już w następnej części.

Ruby on Rails – krok 1

Nie znajdziesz tu uzasadnienia, czemu RoR, czemu taki a nie inny projekt. Najkrócej: „for fun”
Zaczynam na MacOS. Podobno lepiej i łatwiej niż na Win.

1. Instalacja homebrew. Wchodzimy na stronę:

brew.sh

Kopiujemy polecenie do terminala i jedziemy

2. Czas na rbenv (zarządca wersjami Ruby). Wpisujemy w terminalu:

 Brew install rbenv ruby-build 

3. I niech ruby działa zawsze przy odpaleniu terminala:

 echo 'if which rbenv > /dev/null; then eval "$(rbenv init -)"; fi' >> ~/.bash_profilesource ~/.bash_profile 

4. Instalka Ruby:

  rbenv install 2.2.3rbenv global 2.2.3  

Sprawdzenie, jaką mamy wersję Ruby:

   ruby - v  

5. Instalka Ror

gem install rails -v 5.1.6 <br>
rbenv rehash 

Sprawdzenie wersji rails:

   rails —version   

6. Nowy projekt:

a) Stworzy nowy katalog i w nim projekt

rails new Books 

b) Nowy projekt w aktualnym katalogu.

rails new .

Teraz z terminala wchodzę do katalogu z projektem i:

 rails server 

Wchodzę przez przeglądarkę na podany adres (u mnie: http://0.0.0.0:3000)

7. W moich zabawach będzie obecny Bootstrap.

Do pliku gemfile wstawiam:

 gem "twitter-bootstrap-rails" 

Z konsoli uruchamiam:

bundle install 

i:

rails generate bootstrap:install static