Ruby on Rails Zaawansowane programowanie.pdf

(636 KB) Pobierz
Ruby on Rails.
Zaawansowane
programowanie
Autor: Noel Rappin
T‡umaczenie: Justyna Walkowska
ISBN: 978-83-246-1844-6
Tytu‡ orygina‡u: Professional Ruby On Rails
Format: 172x245, stron: 488
Naucz siŒ:
tworzy testy automatyczne dla wszystkich czŒci aplikacji Rails
wdra¿a aplikacje napisane w Ruby przy u¿yciu Capistrano, Mongrel i Apache
broni stron przed atakami
Ruby on Rails (RoR) to sieciowy szkielet open source, pozwalaj„cy utrzyma rwnowagŒ
pomiŒdzy ‡atwoci„ programowania a jego produktywnoci„. To, co odr¿nia ten
framework od innych, to przewaga konwencji nad konfiguracj„, co u‡atwia budowŒ
i zrozumienie aplikacji. Prostota i intuicyjno tego rodowiska pomagaj„ unikn„
powtrzeæ i sprawiaj„, ¿e programowanie jest ‡atwiejsze ni¿ kiedykolwiek. W ci„gu lat
w RoR wprowadzono szereg zmian, zwi„zanych z ewolucj„ technik programistycznych.
Poza tym wystarczaj„c„ rekomendacj„ dla tego rodowiska wydaje siŒ uznanie
wyra¿ane przez takie osoby, jak James Duncan Davidson (twrca Tomcata i Anta), Bruce
Perens (Open Source Luminary), Nathan Torkington (OReilly, OSCON) i wiele innych.
Ksi„¿ka Ruby on Rails. Zaawansowane programowanie jest przeznaczona dla rednio
i bardzo zaawansowanych programistw Rails. Autor zak‡ada, ¿e Czytelnik zna jŒzyk
Ruby i przeczyta‡ chocia¿ jedn„ z dostŒpnych ksi„¿ek, wprowadzaj„cych w wiat Rails,
lub ma za sob„ inn„ formŒ podstawowego kursu. Czytelnik tej ksi„¿ki powinien
wiedzie, jak stworzy prost„ aplikacjŒ Rails. W tej publikacji znajdzie natomiast szereg
odpowiedzi na pytania pojawiaj„ce siŒ po napisaniu pierwszej aplikacji. Autor wyjania,
jak poradzi sobie z u¿ytkownikami i zabezpieczeniami, opisuje obs‡ugŒ stref
czasowych i problemy zwi„zane z u¿ytkowaniem aplikacji w r¿nych stronach wiata
oraz podaje sposoby zabezpieczania strony przed atakami. Czytelnik znajdzie tu porady
dotycz„ce zarz„dzania zespo‡em programistw Rails i kodem rd‡owym, automatyzacji
powtarzalnych zadaæ i wdra¿ania aplikacji w rodowisku produkcyjnym, a tak¿e
sposobw korzystania z nieustannie powstaj„cych rozszerzeæ Rails.
Tworzenie zasobw
Kontrola kodu przy pomocy Subversion (SVN)
Budowanie i automatyzacja
Nawigacja i portale spo‡ecznociowe
Opieka nad bazami danych
JavaScript w Rails
NarzŒdzia do testowania
Metaprogramowanie
Tworzenie wtyczek
Poszerz swojĴ wiedzķ na temat ľrodowiska Ruby on Rails
945199613.001.png 945199613.002.png 945199613.003.png 945199613.004.png
Spis treści
O autorze .................................................................................................................................................. 13
Podziękowania ......................................................................................................................................... 15
Wstęp ........................................................................................................................................................ 17
Kto powinien przeczytać tę książkę ................................................................................ 17
Struktura książki .......................................................................................................... 18
Co jest potrzebne do uruchomienia przykładów ............................................................... 19
Konwencje ................................................................................................................... 20
Kod źródłowy ............................................................................................................... 20
Rozdział 1. Tworzenie zasobów ............................................................................................................... 21
Od czego zacząć? ......................................................................................................... 22
Przepis na przepisy ....................................................................................................... 22
REST — reszta tej historii ............................................................................................. 24
Czym jest REST? ..................................................................................................... 24
Dlaczego REST? ...................................................................................................... 27
Tworzymy pierwsze zasoby ............................................................................................ 27
Migracje ................................................................................................................. 28
Przekierowania ....................................................................................................... 29
Kontrolery .............................................................................................................. 32
Widoki .................................................................................................................... 36
Wyświetlanie przekierowań ...................................................................................... 37
Tworzymy składniki ....................................................................................................... 37
Konfiguracja bazy danych ......................................................................................... 38
Dopasowanie testów do zagnieżdżonych zasobów ...................................................... 39
Tworzymy edytor przepisów ........................................................................................... 42
Dodajemy składniki ................................................................................................. 43
Sprawdzamy poprawność HTML ............................................................................... 43
Parsujemy składniki ................................................................................................ 46
Podrasowujemy stronę ............................................................................................ 49
Testowanie tworzenia zasobów ................................................................................ 50
Dodajemy fragmenty techniki Ajax ............................................................................ 54
Źródła ......................................................................................................................... 57
Podsumowanie ............................................................................................................ 58
6
Ruby on Rails. Zaawansowane programowanie
Rozdział 2. Kontrola kodu za pomocą Subversion ................................................................................. 59
Kontrola kodu ................................................................................................................... 59
Tworzenie repozytorium ...................................................................................................... 62
Wypełnianie repozytorium .............................................................................................. 63
Pobieranie i dodawanie plików ................................................................................. 63
Co ignorować? ........................................................................................................ 64
Pliki bazodanowe w repozytorium ............................................................................. 65
Oznaczanie plików wykonywalnych ............................................................................ 66
Wysyłanie zmian ..................................................................................................... 67
Cykl życia repozytorium ................................................................................................. 68
Wysyłanie zwykłych zmian ........................................................................................ 68
Pobieranie nowszych wersji plików i konflikty ............................................................. 69
Zmiany na poziomie plików ...................................................................................... 70
Konfiguracja serwera Subversion za pomocą svnserve .................................................... 71
Życie na krawędzi ......................................................................................................... 73
Korzystanie z określonej wersji Rails ........................................................................ 74
Rake a życie na krawędzi ......................................................................................... 76
Co słychać u RDoc? ...................................................................................................... 77
Źródła ......................................................................................................................... 79
Podsumowanie ............................................................................................................ 79
Rozdział 3. Dodawanie użytkowników .................................................................................................... 81
Tworzenie użytkowników ............................................................................................... 81
Formularz tworzenia nowego użytkownika ........................................................................ 82
Refaktoryzacja formularzy za pomocą FormBuilder .......................................................... 86
Przechowywanie zaszyfrowanych haseł ........................................................................... 90
Uwierzytelnianie ........................................................................................................... 93
Przekierowania ....................................................................................................... 93
Testy ..................................................................................................................... 93
Kontroler ................................................................................................................ 95
Widoki .................................................................................................................... 96
Korzystanie z uwierzytelniania .................................................................................. 99
Dodawanie ról użytkowników .................................................................................. 100
Ochrona przed botami za pomocą e-maili uwierzytelniających ......................................... 102
Generowanie modelu i migracji ............................................................................... 103
Najpierw testy ....................................................................................................... 104
Logika kontrolera .................................................................................................. 105
Wysyłanie e-maila ................................................................................................. 106
CAPTCHA ................................................................................................................... 108
Tworzenie obiektu CAPTCHA sterowanego testami ................................................... 109
Implementacja obiektu CAPTCHA ........................................................................... 110
Wdrażanie CAPTCHA .............................................................................................. 112
Sesje i ciasteczka ...................................................................................................... 116
Strategie tworzenia ciasteczek umożliwiających trwałe logowanie .............................. 116
Mechanizm trwałego logowania — najpierw testy ..................................................... 117
Cykl życia ciasteczka ............................................................................................. 119
Sprawdzanie ważności ciasteczek .......................................................................... 120
Źródła ....................................................................................................................... 122
Podsumowanie .......................................................................................................... 123
Spis treści
7
Rozdział 4. Budowanie i automatyzacja ................................................................................................125
Co Rake może zrobić dla Ciebie? ................................................................................. 126
Zadania Rake związane z bazami danych ................................................................ 126
Zadania Rake związane z dokumentacją ................................................................. 128
Zadania Rake związane z testowaniem ................................................................... 129
Zadania Rake związane z usuwaniem plików ........................................................... 130
Zadania Rake związane z wersją Rails .................................................................... 130
Inne zadania Rake ................................................................................................ 131
Co Ty możesz zrobić dla Rake? .................................................................................... 132
Proste zadanie Rake ............................................................................................. 132
Zadania z zależnościami ........................................................................................ 133
Zadania plikowe .................................................................................................... 136
Wykorzystanie Rails w Rake ................................................................................... 137
Testowanie zadań Rake ......................................................................................... 138
Ciągła integracja ........................................................................................................ 140
ZenTest ............................................................................................................... 141
CruiseControl.rb .................................................................................................... 142
Źródła ....................................................................................................................... 144
Podsumowanie .......................................................................................................... 145
Rozdział 5. Nawigacja i portale społecznościowe ................................................................................147
Menu i boczne paski nawigacyjne ................................................................................ 147
Menu jednopoziomowe .......................................................................................... 147
Pamięć cache obiektów ......................................................................................... 152
Oznaczanie ................................................................................................................ 154
Instalacja pluginu Acts As Taggable ........................................................................ 154
Dodawanie tagów do modelu ................................................................................. 155
Tagi i interfejs użytkownika .................................................................................... 157
Wyszukiwanie informacji na stronie .............................................................................. 166
Wyszukiwanie z wykorzystaniem SQL ...................................................................... 166
Wyszukiwanie z wykorzystaniem Ferret .................................................................... 169
Stronicowanie ............................................................................................................ 175
will_paginate ........................................................................................................ 175
paginating_find ..................................................................................................... 176
Źródła ....................................................................................................................... 176
Podsumowanie .......................................................................................................... 177
Rozdział 6. Opieka nad bazami danych .................................................................................................. 179
Dostęp do spadku ...................................................................................................... 180
Niekonwencjonalne nazewnictwo ................................................................................. 183
Testowanie zewnętrznej bazy danych w oparciu o pliki z danymi testowymi ...................... 184
Tworzenie związków pomiędzy bazami danych ............................................................... 189
Definiowanie funkcjonalności ................................................................................. 189
Tworzenie modelu pośrednika ................................................................................ 191
Połączenia pomiędzy klasami ................................................................................. 191
Inny mechanizm dostępu do danych ....................................................................... 192
Zyski z bycia normalnym ............................................................................................. 194
Trochę teorii ......................................................................................................... 194
Trochę praktyki ..................................................................................................... 195
Wywołania zwrotne ActiveRecord ............................................................................ 197
Częsty przypadek .................................................................................................. 199
8
Ruby on Rails. Zaawansowane programowanie
Asocjacje polimorficzne ............................................................................................... 199
Ochrona bazy danych .................................................................................................. 201
Ochrona przed SQL Injection za pomocą metody find ............................................... 201
Transakcje ................................................................................................................. 202
Asocjacje jako sposób ochrony przed kradzieżą danych ............................................ 203
Źródła ....................................................................................................................... 203
Podsumowanie .......................................................................................................... 204
Rozdział 7. Narzędzia do testowania ................................................................................................... 205
Programowanie sterowane testami .............................................................................. 205
Pokrycie całości ......................................................................................................... 207
Instalacja rcov ...................................................................................................... 207
Jak korzystać z rcov w Rails? ................................................................................. 208
Testowanie za pomocą atrap ....................................................................................... 211
FlexMock .............................................................................................................. 212
Specyfikacja obiektów i metod typu stub ................................................................. 214
Oczekiwania atrap ................................................................................................. 215
Projektowanie w oparciu o zachowanie ......................................................................... 217
Instalacja RSpec ................................................................................................... 217
Pisanie specyfikacji RSpec .................................................................................... 219
Jak uzyskać funkcjonalności RSpec bez RSpec? ........................................................... 227
Testowanie widoków ............................................................................................. 227
Bardziej naturalna składnia testowania ................................................................... 230
Lepsze dane do testów ......................................................................................... 231
Testowanie pomocników ........................................................................................ 232
Źródła ....................................................................................................................... 234
Podsumowanie .......................................................................................................... 235
Rozdział 8. JavaScript w Rails ............................................................................................................. 237
Powrót do przeszłości ................................................................................................. 238
Usuwamy zduplikowany kod ................................................................................... 239
Trochę gracji ......................................................................................................... 243
Łatwa i przyjemna integracja kodu JavaScript ................................................................ 248
Podpowiedzi ......................................................................................................... 248
Edycja bezpośrednia .............................................................................................. 251
Autocomplete ....................................................................................................... 254
Pisanie kodu JavaScript w języku Ruby ......................................................................... 255
Przykład RJS ......................................................................................................... 256
Inne metody RJS ................................................................................................... 258
Okienka typu lightbox ............................................................................................ 259
Jak testować RJS? ................................................................................................ 261
Ochrona przed atakiem Cross-Site Scripting ................................................................. 262
Źródła ....................................................................................................................... 264
Podsumowanie .......................................................................................................... 264
Rozdział 9. Rozmowy z siecią ............................................................................................................... 265
ActiveResource .......................................................................................................... 265
Strona kliencka REST ............................................................................................ 266
Aktywacja zasobów ............................................................................................... 267
Wytwarzanie danych przez usługi sieciowe .................................................................... 270
Wytwarzanie XML .................................................................................................. 270
Szablony budujące ................................................................................................ 272

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin