.:$$:.

• Jak osiągnąć największe korzyści z architektury MVC?
• Jak programować, korzystając z bloków?
• Jak tworzyć Web API?

Ruby on Rails przebojem wdarł się na rynek szkieletów aplikacji internetowych. Stworzony w architekturze MVC z wykorzystaniem popularnego języka Ruby, został entuzjastycznie przyjęty przez społeczność programistów. Główne założenia tego projektu to łatwość i przyjemność tworzenia kodu, a co za tym idzie -- szybkie i efektywne tworzenie aplikacji internetowych. Liczba rozwiązań, które powstały z wykorzystaniem tego szkieletu, świadczy o jego wysokiej jakości oraz znacząco wpływa na wzrost popularności samego języka Ruby.

Jeżeli ta książka znalazła się w Twoich rękach, to z pewnością powyższe wiadomości nie są Ci obce. Kierowana jest ona do programistów, którzy znają już Ruby on Rails i pragną pogłębić swoją wiedzę. Dzięki książce "Rails. Sztuka programowania" dowiesz się, jak organizować swój kod tak, aby osiągnąć najwyższą efektywność i zachować zgodność z ideą DRY (Don"t Repeat Yourself). Poznasz zasady zaawansowanego programowania w języku Ruby wraz z metaprogramowaniem oraz nauczysz się korzystać z programowania opartego na blokach. Ponadto zapoznasz się z wzorcami projektowymi dla technologii AJAX, interfejsami programistycznymi dla WWW, dekompozycją kodu HTML oraz nauczysz się w wydajny sposób rozwijać schemat bazy danych. Z pewnością zainteresuje Cię rozdział poświęcony programowaniu sterowanym zachowaniem. Te i wiele innych informacji znajdziesz w niniejszej książce, która wydaje się być obowiązkową dla każdego programisty Ruby on Rails!

• Cała prawda o aplikacjach internetowych
• Koncepcja Rails
• Architektura MVC
• Zarządzanie cyklem życia aplikacji
• Korzyści z zastosowania architektury MVC
• Zastosowanie technologii ActiveRecord
• Tworzenie Web API
• Wykorzystanie zasobów oraz obsługa żądań REST
• Zastosowanie formatów XML, RSS, RDF
• Sposoby ograniczania dostępu do API
• Wzorce zastosowań technologii AJAX
• Zasady programowania z wykorzystaniem bloków
• Mieszanie i łatanie klas
• Wykorzystanie dynamicznego kodu
• RSpec -- programowanie sterowane zachowaniem
• Cykl programowania

• Rails, sztuka i nowy internet (23)
• Sztuka i inżynieria (23)
• Nowe witryny WWW (24)
• Prawda o aplikacjach internetowych (25)
• Historia pacjenta - witryny internetowe (26)
• Od dokumentów do interfejsów (29)
• Upadek semantyki (30)
• Witajcie, aplikacje internetowe (33)
• Pojawienie się nowego podejścia (40)

• W jednej części szkielet (43)
• Konfiguracja (43)
• Kod (45)
• Proces (46)
• W jednej części język (48)
• Modele w Rails (49)
• Zadania specyficzne dla stron WWW (51)
• JavaScript (52)
• Moduły dodatkowe (53)
• W dwóch częściach sposób myślenia (53)
• Witryny internetowe to aplikacje MVC (54)
• Aplikacje internetowe to ekosystemy (54)
• Konwencja ponad konfigurację (55)
• Małe założenie przebywa długą drogę (56)
• Kwestie estetyczne (57)
• Wyzwalające ograniczenia (58)
• Zbyt mocno się powtarzasz (60)
• Testowanie nie jest opcjonalne (62)
• Sieć to zbiór zasobów, a nie usług (63)
• Podsumowanie (64)
• Złoty środek nie istnieje (65)
• Optymizuj swój sposób kodowania, zanim przystąpisz do optymalizacji kodu (65)

• Model-widok-kontroler w wersji skróconej (69)
• MVC i strony WWW (71)
• Proces projektowy MVC (72)
• Widok to specyfikacja (73)
• Przykład - portal społecznościowy dla kucharzy (74)
• Zarządzanie cyklem życia aplikacji (78)
• Myśl w sposób lekki, nie inżynieryjny (78)
• Myśl w sposób kontrolowany, a nie organiczny (79)
• Strzeż się operacji na otwartym sercu (79)
• Podsumowanie (80)

• Najlepsza dokumentacja interfejsów jest gratis (82)
• Model (83)
• Obiekty modeli powinny się nawzajem rozumieć (84)
• Użyj wyjątków, by zwiększyć czytelność kodu (86)
• Odwzorowanie z wierszy na obiekty (89)
• Asocjacje polimorficzne (90)
• Świat poza ActiveRecord (92)
• Widok (92)
• Problem zmiennej (93)
• JavaScript w stylu Rails (94)
• Fragmenty jako atomy i molekuły (95)
• Wybór odpowiednich fragmentów (97)
• Widok to nie tylko HTML (99)
• Kontroler (100)
• CRUD do wielokrotnego zastosowania (101)
• Rusztowanie w Rails to zbiór operacji CRUD (102)
• Obsługa akcji dwukrokowych (103)
• Kiedy przekazać prace na zewnątrz (106)
• Kiedy refaktoryzować (110)
• Podsumowanie (111)

• Dwa wielkie pomysły na Web API (115)
• Nowy adres URL - adresacja zagadnień, nie plików (115)
• Aplikacja to interfejs (117)
• Odwzorowania adresów (118)
• Anatomia wywołania Web API (121)
• Nakładanie API (121)
• Metoda respond_to (122)
• Zapis wyniku w formacie innym niż HTML (124)
• Dodanie własnych typów MIME (127)
• Rejestracja typów w Rails (128)
• Tworzenie własnego typu MIME (129)
• Ograniczanie dostępu do API w sposób zgodny z Rails (129)
• Uwierzytelnienie użytkownika (130)
• Algorytm ograniczający (131)
• Wprowadzenie ograniczeń za pomocą filtrów (132)
• Co z usługami SOAP i XML-RPC (133)
• Interfejs usługi (134)
• Implementacja usługi (135)
• Tworzenie struktur (136)
• Podsumowanie (137)

• Sieć zasobów (141)
• Identyfikacja zasobów (141)
• Mówienie o zasobach (142)
• Reprezentacja zasobów (142)
• REST (143)
• HTTP, czyli CRUD dla zasobów (144)
• Definiowanie aplikacji w kategorii zasobów (146)
• Komunikacja z klientem, czyli zasoby jako API (151)
• Inny sposób, czyli sieć to komputer (151)
• REST i Rails (153)
• Odwzorowanie zasobów w routerze (153)
• Ponieważ świat nie jest idealny, nadal potrzebujemy odwzorowań nazwanych (154)
• Automatycznie tworzone odwzorowania (156)
• Rusztowanie dla zasobów (158)
• Zagnieżdżone zasoby (158)
• Zasoby jako singletony czy zasoby tradycyjne (161)
• Podsumowanie (162)

• Wielkie sekrety (165)
• Niekoniecznie AJAX stanowi najtrudniejszy element systemu (165)
• AJAX wymaga podjęcia trudnych decyzji projektowych (166)
• Nawet w Rails można zdecydować się na własną bibliotekę JavaScriptu (167)
• Pięć stylów AJAX-a (169)
• Styl pośrednika (171)
• Styl fragmentowy (173)
• Styl marionetkowy (175)
• Kompilacja do JavaScriptu (177)
• Styl bezpośredniej edycji w aplikacji (179)
• AJAX jako jeszcze jeden interfejs programistyczny (181)
• AJAX w stylu Rails (183)
• Kontroler ajaksowy ze stylem fragmentowym (i AJAX CRUD) (183)
• Kontrolery ajaksowe ze stylem marionetkowym (i RJS) (186)
• Elegancka degradacja (189)
• Cofanie się ze stylu fragmentowego (189)
• Wycofywanie się z bogatych interfejsów użytkownika (191)
• Podsumowanie (192)

• Bloki jako sposób programowania (196)
• Porównanie metod, procedur i bloków (200)
• Metody (200)
• Procedury (204)
• Bloki (205)
• Przenoszenie się między blokami i procedurami (206)
• Duży eksperyment z zasięgiem (207)
• Eksperyment 1. - na bloki wpływa zmiana ich środowiska źródłowego (208)
• Eksperyment 2. - bloki mogą wpłynąć na środowisko, z którego się wywodzą (210)
• Wzorce blokowe i bloki w Rails (212)
• Iteracja (212)
• Programowanie aspektowe (214)
• Tworzenie danych wyjściowych w HTML-u i XML-u (218)
• Funkcje o podwójnym zastosowaniu (220)
• Wywołania zwrotne (220)
• Podsumowanie (222)

• Dołączenia (225)
• Organizacja kodu w formie modułów (225)
• Metody w modułach (227)
• Dołączanie modułów do klas (228)
• Dołączenia w Rails (232)
• Małpie łatanie (236)
• Metoda eval - tyle drzwi do interpretera (237)
• Rodzeństwo metody eval (239)
• Dobra technika tworzenia łat (245)
• Podsumowanie (249)

• Jeszcze raz o dynamicznym kodzie i DSL (253)
• Makra piszące kod (254)
• Tworzenie metod w locie za pomocą define_method (254)
• Przykład użycia define_method - Pentagon i Kreml (255)
• Zasięg i define_method (257)
• Zastosowanie define_method w makrach Rails (258)
• Podsumowanie makr (260)
• Wywoływanie nieistniejących metod - obiekty dostosowujące się do sposobów korzystania z nich (261)
  
  • Kilka prostych przykładów (262)
  • Przykład - skrót dla Array.each (263)
  • Uważaj na wyłapywanie wszystkiego (266)
  • Wzorce metody method_missing (267)
  • Implementacja wzorców method_missing (268)
  • Obiekty sterowane danymi - tworzenie tłumacza komputerowego (272)
• Introspekcja (274)
• Zmienne i stałe (275)
• Metody (276)
• Moduły (277)
• Podsumowanie (278)

• Bazy danych w aplikacjach internetowych - stos LAMP (280)
• Myślenie w kategoriach migracji (282)
• Tworzenie migracji (284)
• Przeprowadzanie migracji danych (286)
• Rozwój schematu w większym zespole (286)
• Populacja bazy danymi produkcyjnymi (288)
• Niewielkie zestawy danych - populacja danych w migracji (289)
• Zestawy danych średniej wielkości - pliki danych (290)
• Duże zestawy danych - pliki zrzutów bazy danych (291)
• Gdy baza danych nie wystarcza (293)
• Hierarchia obiektów modeli (293)
• Przechowywanie list, słowników i innych elementów (297)
• Własne funkcje pobierające i ustawiające (299)
• Podsumowanie (300)

• Programowanie sterowane zachowaniem (303)
• RSpec - BDD dla Ruby on Rails (305)
• Cykl programowania specyfikacji (305)
• Pisanie specyfikacji (306)
• Implementacja przykładów (308)
• Dopasowania (309)
• Własne dopasowania (311)
• Przed i po (313)
• Przykładowy cykl programowania (314)
• Część 1. Tworzenie historyjki (314)
• Część 2. Tworzenie specyfikacji (315)
• Część 3. Inicjalizacja i napisanie prostego testu (316)
• Część 4. Tworzenie testów zachowań motywujących do pisania kodu (318)
• Część 5. Uzupełnianie implementacji testów zachowań (319)
• Ale to nie wszystko (321)
• Podsumowanie (322)