Agile. Programowanie w Rails. Wydanie II

• Jak zbudować sprawny sklep internetowy?
• Jak korzystać z generatorów kodu?
• Jak utworzyć nowoczesny serwis internetowy?

Rails, którego podstawowym budulcem są zasady programowania zwinnego (agile), jest kompletnym środowiskiem do tworzenia aplikacji internetowych w architekturze MVC. Pozwala na budowanie sprawnych i profesjonalnych serwisów internetowych, zaprojektowanych i zaimplementowanych z użyciem najnowocześniejszych technologii.

Wykorzystuje zwięzły i precyzyjny język Ruby, rozszerzając go w nowatorski sposób, dzięki temu programy stają się krótsze i bardziej czytelne. Stosowanie Rails umożliwia upraszczanie struktur i zapewnia funkcjonalność aplikacji internetowych, pozwala także na szybkie nanoszenie poprawek, co sprawia, że napisane w ten sposób strony WWW przetrwają próbę czasu, mimo pojawiających się wciąż nowych rozwiązań informatycznych.

"Agile. Programowanie w Rails. Wydanie II" to książka prezentująca obszernie i jednocześnie przystępnie możliwości programowania w środowisku Rails. Podczas pracy z tym podręcznikiem nauczysz się wszystkiego o nowoczesnych i dynamicznych aplikacjach, począwszy od ich projektowania, poprzez instalację, a skończywszy na administrowaniu nimi i wprowadzaniu zmian. Dowiesz się, jak od podstaw zbudować profesjonalny sklep oraz skuteczny serwis internetowy. Jeśli trzymasz w ręce tę książkę, jesteś już tylko o krok od poznania tajników najnowocześniejszych i najsprawniejszych stron WWW.

• Architektura aplikacji Rails
• Instalacja i uaktualnienia
• Testowanie konfiguracji
• Tworzenie formularza zbierającego zmówienia
• Zarządzanie kontami użytkowników
• Testy jednostkowe modeli
• Testy funkcjonalne kontrolerów
• Testy integracyjne aplikacji
• Active Support
• Migracje
• Active Record
• Action Controller
• Komponent Action Mailer
• Wprowadzenie do języka Ruby

• 1.1. Rails a metody agile (18)
• 1.2. Kilka słów o strukturze książki (20)
• 1.3. Podziękowania (23)

• 2.1. Modele, widoki i kontrolery (27)
• 2.2. Active Record - obsługa modelu w Rails (31)
• 2.3. Action Pack - widok i kontroler (36)

• 3.1. Twoja lista zakupów (40)
• 3.2. Instalacja w systemie Windows (41)
• 3.3. Instalacja w systemie Mac OS X (43)
• 3.4. Instalacja w systemie Linux (45)
• 3.5. Środowisko robocze (46)
• 3.6. Rails i bazy danych (51)
• 3.7. Uaktualnienia (54)
• 3.8. Rails a dostawcy usług internetowych (55)

• 4.1. Tworzenie nowej aplikacji (57)
• 4.2. Witaj Rails! (60)
• 4.3. Łączenie stron ze sobą (73)
• 4.4. Co właśnie zrobiliśmy? (77)

• 5.1. Programowanie przyrostowe (82)
• 5.2. Czym się zajmuje Składnica? (82)
• 5.3. Czas na kod (87)

• 6.1. Iteracja A1 - coś działającego (90)
• 6.2. Iteracja A2 - dodanie brakującej kolumny (105)
• 6.3. Iteracja A3 - walidacja (107)
• 6.4. Iteracja A4 - ładniejsze listy (112)

• 7.1. Iteracja B1 - utworzenie katalogu (124)
• 7.2. Iteracja B2 - dodanie układu strony (128)
• 7.3. Iteracja B3 - użycie metody pomocniczej do formatowania ceny (130)
• 7.4. Iteracja B4 - połączenie z koszykiem (131)

• 8.1. Sesje (136)
• 8.2. Iteracja C1 - tworzenie koszyka (140)
• 8.3. Iteracja C2 - inteligentny koszyk (143)
• 8.4. Iteracja C3 - obsługa błędów (148)
• 8.5. Iteracja C4 - ostatnie poprawki w koszyku (154)

• 9.1. Iteracja D1 - przesuwanie koszyka (160)
• 9.2. Iteracja D2 - koszyk oparty na Ajaksie (166)
• 9.3 Iteracja D3 - wyróżnianie zmian (171)
• 9.4. Iteracja D4 - ukrycie pustego koszyka (174)
• 9.5. Iteracja D5 - gdy JavaScript jest wyłączony (178)
• 9.6. Podsumowanie (180)

• 10.1. Iteracja E1 - przyjmowanie zamówienia (184)

• 11.1. Iteracja F1 - dodawanie użytkowników (202)
• 11.2. Iteracja F2 - logowanie (211)
• 11.3. Iteracja F3 - ograniczanie dostępu (214)
• 11.4. Iteracja F4 - panel boczny oraz zarządzania ciąg dalszy (217)

• 12.1. Generowanie kanału XML (226)
• 12.2. Ostatnie szlify (234)

• 13.1. Z myślą o testach (238)
• 13.2. Testy jednostkowe modeli (239)
• 13.3. Testy funkcjonalne kontrolerów (254)
• 13.4. Testy integracyjne aplikacji (273)
• 13.5. Testowanie wydajności (283)
• 13.6. Korzystanie z atrap (288)

• 14.1. Gdzie jest Rails? (293)
• 14.2. Struktura katalogów (294)
• 14.3. Konfiguracja Rails (304)
• 14.4. Konwencje nazewnicze (308)
• 14.5. Raportowanie w Rails (313)
• 14.6. Usuwanie błędów - kilka wskazówek (314)
• 14.7. Co dalej? (317)

• 15.1. Ogólnie dostępne rozszerzenia (319)
• 15.2. Wyliczenia i tablice (320)
• 15.3. Rozszerzenia łańcuchów znaków (322)
• 15.4. Rozszerzenia obiektów numerycznych (325)
• 15.5. Rozszerzenia obiektów daty i czasu (327)
• 15.6. Rozszerzanie symboli Ruby'ego (331)
• 15.7. Metoda with_options (332)
• 15.8. Obsługa Unicode (333)

• 16.1. Tworzenie i uruchamianie migracji (343)
• 16.2. Zawartość migracji (345)
• 16.3. Zarządzanie tabelami (350)
• 16.4. Migracje danych (355)
• 16.5. Zaawansowane migracje (359)
• 16.6. Gdy coś pójdzie nie tak (362)
• 16.7. Manipulowanie schematem poza migracjami (363)
• 16.8. Zarządzanie migracjami (364)

• 17.1. Tabele i klasy (368)
• 17.2. Kolumny i atrybuty (369)
• 17.3. Klucze główne i identyfikatory (374)
• 17.4. Łączenie się z bazą danych (376)
• 17.5. CRUD - utwórz, odczytaj, zaktualizuj i usuń (383)
• 17.6. Agregacja i dane złożone (406)
• 17.7. Różności (414)

• 18.1. Tworzenie kluczy obcych (421)
• 18.2. Określanie związków w modelach (423)
• 18.3. Deklaracje belongs_to i has_xxx (425)
• 18.4. Złączenia wielu tabel (445)
• 18.5. Złączenia ze sobą samym (456)
• 18.6. Imitacje (457)
• 18.7. Kiedy następuje zapis (462)
• 18.8. Wstępne ładowanie wierszy potomnych (464)
• 18.9. Liczniki (466)

• 19.1. Walidacja (469)
• 19.2. Wywołania zwrotne (483)
• 19.3. Zaawansowane atrybuty (492)
• 19.4. Transakcje (496)

• 20.1. Podstawy (506)
• 20.2. Routing żądań (507)

• 21.1. Metody akcji (545)
• 21.2. Cookies i sesje (560)
• 21.3. Migawka - komunikacja pomiędzy akcjami (574)
• 21.4. Filtry i weryfikacja (577)
• 21.5. Pamięć podręczna - część pierwsza (585)
• 21.6. Problem z żądaniami GET (594)

• 22.1. Szablony (599)
• 22.2. Metody pomocnicze (607)
• 22.3. Metody pomocnicze służące do formatowania, tworzenia łączy i paginacji (609)
  
• 22.4. Jak działają formularze (620)
• 22.5. Formularze odwzorowujące obiekty modelu (622)
• 22.6. Praca z własnymi budowniczymi formularzy (637)
• 22.7. Pola niezwiązane z modelami (642)
• 22.8. Wysyłanie plików do aplikacji Rails (646)
• 22.9. Układy i komponenty (650)
• 22.10. Pamięć podręczna - część druga (661)
• 22.11. Dodawanie nowych systemów szablonów (667)

• 23.1. Prototype (672)
• 23.2. Script.aculo.us (698)
• 23.3. Szablony rjs (718)
• 23.4. Podsumowanie (728)

• 24.1. Wysyłanie poczty elektronicznej (729)
• 24.2. Odbieranie poczty elektronicznej (742)
• 24.3. Testowanie poczty elektronicznej (745)

• 25.1. Czym jest, a czym nie jest AWS (750)
• 25.2. Definicja API (751)
• 25.3. Tryby kierowania (757)
• 25.4. Korzystanie z alternatywnych metod kierowania (759)
• 25.5. Przechwytywanie wywołań metod (761)
• 25.6. Testowanie usług sieciowych (763)
• 25.7. Klienty usług sieciowych (766)

• 26.1. Wstrzykiwanie kodu SQL (772)
• 26.2. Tworzenie rekordów bezpośrednio z danych formularza (775)
• 26.3. Nie ufaj identyfikatorom (777)
• 26.4. Nie udostępniaj publicznie metod kontrolera (778)
• 26.5. Ataki XSS (779)
• 26.6. Kradzież identyfikatora sesji (782)
• 26.7. Wysyłanie plików na serwer (783)
• 26.8. Nie przechowuj ważnych informacji bez zabezpieczenia (784)
• 26.9. Używaj protokołu SSL do transmisji poufnych danych (786)
• 26.10. Nie buforuj stron chronionych uwierzytelnianiem (788)
• 26.11. Testowanie (788)

• 27.1. Wczesny początek (790)
• 27.2. Jak działa serwer produkcyjny (791)
• 27.3. Porównanie serwerów WWW (794)
• 27.4.Automatyzacja wdrożeń za pomocą Capistrano (796)
• 27.5.Przygotowanie środowiska wdrożeniowego (797)
• 27.6. Śledzenie wdrożonej aplikacji (804)
• 27.7. Utrzymanie aplikacji produkcyjnej (805)
• 27.8. Po wdrożeniu (807)

• A.1. Ruby jest językiem obiektowym (811)
• A.2. Nazwy w Rubym (813)
• A.3. Metody (814)
• A.4. Klasy (816)
• A.5. Moduły (819)
• A.6. Tablice i tablice asocjacyjne (819)
• A.7. Struktury kontrolne (821)
• A.8. Wyrażenia regularne (822)
• A.9. Bloki i iteratory (823)
• A.10. Wyjątki (824)
• A.11. Serializacja obiektów (824)
• A.12. Interaktywna konsola Ruby'ego (825)
• A.13. Idiomy Ruby'ego (826)
• A.14. Dokumentacja RDoc (828)

• B.1. Konfiguracja ogólna (830)
• B.2. Konfiguracja Active Record (832)
• B.3. Konfiguracja komponentu Action Controller (835)
• B.4. Konfiguracja komponentu Action View (837)
• B.5. Konfiguracja komponentu Action Mailer (838)
• B.6. Konfiguracja przypadków testowych (839)

• C.1. Aplikacja Składnica (841)

• D.1. Strony internetowe (869)
• D.2. Bibliografia (870)