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

Osoby które kupowały "Ruby on Rails. Zaawansowane programowanie", wybierały także:

• Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
• Programowanie w Ruby. Poziom drugi. Kurs video. Zaawansowane techniki 69,00 zł, (27,60 zł -60%)
• Ruby on Rails (RoR). Kurs video. Programowanie aplikacji internetowych 99,00 zł, (44,55 zł -55%)
• Ruby. Kurs video. Poziom pierwszy. Podstawy języka i praktyczne przykłady 79,00 zł, (35,55 zł -55%)
• Ruby on Rails. Kurs video. Wdrażanie (deployment) na własne serwery i chmurę 59,00 zł, (26,55 zł -55%)

Spis treści

Ruby on Rails. Zaawansowane programowanie -- 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)

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)

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)
• 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)
  • Wytwarzanie szybko zmieniających się danych (273)
  • Wytwarzanie danych JSON i YAML (279)
• Konsumowanie usług sieciowych (281)
  
• Źródła (282)
  
• Podsumowanie (283)

Rozdział 10. Umiędzynaradawianie aplikacji (285)

• Kogo obchodzi czas? (285)
  
  • Data i czas (286)
  • Zapis dat i godzin a strefy czasowe (287)
  • Wprowadzanie dat (290)
  • Działania na datach i wyświetlanie dat (295)
• Umiędzynaradawianie za pomocą Globalize (298)
  
  • Korzystanie z pluginu Globalize (298)
  • Formatowanie lokalne (300)
  • Tłumaczenie (301)
  • Śledzenie przekierowań (306)
• Źródła (307)
  
• Podsumowanie (307)

Rozdział 11. Sztuki piękne (309)

• Zaczynamy (309)
  
  • Pakiety graficzne (310)
  • Instalacja w systemie Windows (310)
  • Instalacja w systemie Mac OS X (311)
  • Instalacja w systemie Linux (312)
• Przesyłanie plików do Rails (312)
  
  • Konfiguracja danych attachment_fu (313)
  • Tworzenie modelu attachment_fu (314)
  • Testowanie attachment_fu (315)
  • Dodawanie formularza attachment_fu (317)
  • Wyświetlanie obrazków przez attachment_fu (318)
• Korzystanie z bibliotek graficznych (320)
  
  • ImageScience (320)
  • RMagick (321)
  • MiniMagick (327)
• Wykresy (330)
  
  • Gruff (330)
  • Sparklines (333)
• Źródła (335)
  
• Podsumowanie (335)

Rozdział 12. Wdrażanie aplikacji (337)

• Capistrano (337)
  
  • Zaczynamy pracę z Capistrano (338)
  • Podstawowe zadania Capistrano (340)
  • Dopasowanie Capistrano do własnych potrzeb (344)
  • Wdrażanie etapami (349)
• Mongrel (350)
  
  • Zaczynamy (350)
  • Proste wdrożenie (352)
  • Wdrażanie z wykorzystaniem wielu instancji serwera (353)
  • Mongrel, Apache i Ty (357)
• Źródła (358)
  
• Podsumowanie (358)

Rozdział 13. Wydajność (361)

• Pomiary (361)
  
  • Railsbench (362)
  • Wydajność poszczególnych składowych programu (368)
• Poprawa wydajności (375)
  
  • Przechowywanie sesji (377)
  • Problemy z ActiveRecord i bazami danych (380)
• Caching (384)
  
  • Caching stron (385)
  • Caching akcji (386)
  • Caching fragmentów widoków (386)
  • Usuwanie starych plików cache (387)
  • Przechowywanie cache (388)
• Źródła (388)
  
• Podsumowanie (389)

Rozdział 14. Poziom meta (391)

• Eval i wiązania (392)
  
• Introspekcja (394)
  
• Klasy, metaklasy i singletony (397)
  
  • Klasy i obiekty (397)
  • Singletony (399)
• Monkey patching i duck punching (402)
  
  • O tym, jak podczas małpiego łatania nie pośliznąć się na skórce od banana (403)
  • Alias (404)
  • Jak robią to pluginy (406)
  • Acts As Reviewable (406)
• Brakujące metody (409)
  
• Dynamiczne definiowanie metod (411)
  
• Źródła (413)
  
• Podsumowanie (414)

Rozdział 15. Tworzenie pluginów (415)

• Korzystanie z pluginów (415)
  
  • Instalacja pluginów (416)
  • Repozytoria z pluginami (417)
• Tworzenie pluginu (418)
  
• Pisanie generatora (421)
  
  • Podstawowe funkcjonalności generatora (421)
  • Klasa generatora (422)
  • Manifest generatora (423)
  • Testowanie generatorów (424)
  • Pisanie testu generatora (426)
  • GeneratorTestHelper (428)
  • Migracja, która pomyślnie przechodzi testy (430)
• Pisanie pluginu (430)
  
  • Konfiguracja testów ActiveRecord (430)
  • Struktura Acts As Reviewable (434)
• Dystrybucja pluginów (437)
  
• Źródła (437)
  
• Podsumowanie (438)

Rozdział 16. Rails bez Ruby? (439)

• Alternatywy dla ERB (439)
  
  • Markaby (440)
  • Haml (443)
  • Liquid (449)
• JRuby on JRails (453)
  
  • Zaczynamy (453)
  • Przekraczanie granic (455)
  • Uruchamianie JRails (457)
  • Wdrażanie z wykorzystaniem plików WAR (459)
  • GlassFish (460)
• Źródła (461)
  
• Podsumowanie (461)

Dodatek A: Co należy zainstalować? (463)

• Różne platformy (463)
  
  • Linux (463)
  • Mac OS X (463)
  • Windows (464)
• Ruby (464)
  
• Rails (465)
  
• Subversion (465)
  
• Bazy danych (465)
  
• Mongrel (466)
  
• Edytor tekstu (466)
  
• Za jednym zamachem (467)

Dodatek B: Środowiska sieciowe zainspirowane Rails (469)

• CakePHP (469)
  
• Camping (469)
  
• Django (470)
  
• Grails (470)
  
• Merb (471)
  
• TurboGears (471)

Skorowidz (473)