Ruby on Rails Zaawansowane programowanie.pdf

(617 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æ równowagê
pomiêdzy ³atwoœci¹ programowania a jego produktywnoœci¹. 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¹æ
powtórzeñ 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 (twórca Tomcata i Anta), Bruce
Perens (Open Source Luminary), Nathan Torkington (O’Reilly, OSCON) i wiele innych.
Ksi¹¿ka „Ruby on Rails. Zaawansowane programowanie” jest przeznaczona dla œrednio
i bardzo zaawansowanych programistów 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 wyjaœnia,
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 programistów Rails i kodem Ÿród³owym, automatyzacji
powtarzalnych zadañ i wdra¿ania aplikacji w œrodowisku produkcyjnym, a tak¿e
sposobów korzystania z nieustannie powstaj¹cych rozszerzeñ Rails.
• Tworzenie zasobów
• Kontrola kodu przy pomocy Subversion (SVN)
• Budowanie i automatyzacja
• Nawigacja i portale spo³ecznoœciowe
• Opieka nad bazami danych
• JavaScript w Rails
• Narzêdzia do testowania
• Metaprogramowanie
• Tworzenie wtyczek
Poszerz swoj¹ wiedzê na temat œrodowiska Ruby on Rails
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