Rails. Sztuka programowania - ebook

• 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

O autorze (11)

Podziękowania (13)

Wprowadzenie (15)

Rozdział 1. Rozwój nowego systemu witryn internetowych (21)

• 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)

Rozdział 2. Koncepcja Rails (41)

• 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)

Rozdział 3. Serwer jako aplikacja (67)

• 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)

Rozdział 4. Osiągnięcie jak największych korzyści z M, V i C (81)

• 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)

Rozdział 5. Piękne interfejsy aplikacji (113)

• 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)

Rozdział 6. Zasoby i REST (139)

• 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)

Rozdział 7. Pięć stylów AJAX-a (163)

• 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)

Rozdział 8. Zabawa z blokami (193)

• 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)

Rozdział 9. Mieszanie i łatanie klas (223)

• 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)

Rozdział 10. Kod, który pisze kod (który pisze kod) (251)

• 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)

Rozdział 11. Jak przestałem się martwić i pokochałem schemat bazy danych (279)

• 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)

Rozdział 12. RSpec - programowanie sterowane zachowaniem (301)

• 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)

Skorowidz (323)