Ruby on Rails Zaawansowane programowanie.pdf
(
623 KB
)
Pobierz
Ruby on Rails. Zaawansowane programowanie
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
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:
Ravel25
Inne pliki z tego folderu:
Asembler dla procesorow Intel Vademecum profesjonalisty.pdf
(400 KB)
Asembler cwiczenia praktyczne.pdf
(358 KB)
Architektura systemow zarzadzania przedsiebiorstwem Wzorce projektowe.pdf
(829 KB)
Architektura oprogramowania Metody oceny oraz analiza przypadkow.pdf
(429 KB)
Aplikacje w Visual C++ 2005 Przyklady.pdf
(296 KB)
Inne foldery tego chomika:
(X) HTML
algorytmy i struktury danych
asembler
C++
Core JAVA2 Podstawy
Zgłoś jeśli
naruszono regulamin