Ruby. Tao programowania w 400 przykładach

• Omówienie możliwości języka Ruby
• Zasady komunikacji z bazami danych
• Tworzenie interfejsów graficznych dla aplikacji
• Testowanie kodu źródłowego

Ruby, obiektowy język programowania, opracowany na początku lat 90. ubiegłego wieku w Japonii, cieszy się zasłużoną i stale rosnącą popularnością. Dziś Ruby jest poważną konkurencją dla Perla i podstawowym fundamentem technologii Ruby on Rails -- doskonałego narzędzia do szybkiego tworzenia aplikacji i witryn internetowych. Prosta składnia, duże możliwości, zwarta konstrukcja, rozbudowana i niezwykle wygodna obsługa wyjątków oraz przetwarzania plików tekstowych sprawiają, że po ten język programowania sięga coraz więcej osób piszących oprogramowanie.

Książka "Ruby. Tao programowania w 400 przykładach" to podręcznik dla tych programistów, którzy poszukują metod rozwiązywania konkretnych zadań programistycznych za pomocą Ruby. Na ponad 400 przykładach przedstawiono w niej przeróżne zastosowania i możliwości tego języka. Czytając ją, poznasz elementy języka Ruby i zasady programowania obiektowego, techniki przetwarzania łańcuchów tekstowych z zastosowaniem wyrażeń regularnych oraz sposoby wykonywania nawet najbardziej złożonych operacji matematycznych. Znajdziesz tu także omówienie metod komunikacji z bazami danych, budowania graficznych interfejsów użytkownika, programowania wielowątkowego i pisania skryptów administracyjnych. Dowiesz się też, jak korzystać z frameworka Ruby on Rails.

• Programowanie obiektowe w Ruby
• Przetwarzanie danych tekstowych
• Obliczenia matematyczne
• Internacjonalizacja aplikacji
• Operacje na złożonych strukturach danych
• Dynamiczne elementy języka Ruby
• Tworzenie interfejsów graficznych dla aplikacji
• Aplikacje wielowątkowe
• Pobieranie danych z baz
• Dystrybucja aplikacji
• Testowanie
• Tworzenie aplikacji internetowych w technologii Ruby on Rails

• 1.1. Wprowadzenie do programowania obiektowego (48)
• 1.1.1. Czym jest obiekt? (49)
• 1.1.2. Dziedziczenie (50)
• 1.1.3. Polimorfizm (53)
• 1.1.4. Kilka dodatkowych pojęć (54)
• 1.2. Podstawy składni i semantyki języka Ruby (55)
• 1.2.1. Słowa kluczowe i identyfikatory (57)
• 1.2.2. Komentarze i dokumentacja osadzana w kodzie źródłowym (58)
• 1.2.3. Stałe, zmienne i typy (58)
• 1.2.4. Operatory i priorytety operatorów (61)
• 1.2.5. Program przykładowy (62)
• 1.2.6. Pętle i struktury sterujące (65)
• 1.2.7. Wyjątki (70)
• 1.3. Programowanie obiektowe w języku Ruby (73)
• 1.3.1. Obiekty (74)
• 1.3.2. Klasy wbudowane (74)
• 1.3.3. Moduły i klasy mieszane (76)
• 1.3.4. Tworzenie klas (77)
• 1.3.5. Metody i atrybuty (82)
• 1.4. Aspekty dynamiczne języka programowania Ruby (84)
• 1.4.1. Kodowanie w czasie wykonywania (85)
• 1.4.2. Refleksja (86)
• 1.4.3. Brakujące metody (88)
• 1.4.4. Odzyskiwanie pamięci (89)
• 1.5. Ćwiczenie intuicji: o czym warto pamiętać (90)
• 1.5.1. Wybrane reguły składniowe (90)
• 1.5.2. Różne spojrzenia na programowanie (93)
• 1.5.3. Wyrażenie case języka Ruby (97)
• 1.5.4. Rubyizmy i idiomy (100)
• 1.5.5. Orientacja na wyrażenia i inne zagadnienia (106)
• 1.6. Żargon języka Ruby (108)
• 1.7. Konkluzja (112)

• 2.1. Reprezentowanie typowych łańcuchów (114)
• 2.2. Reprezentowanie łańcuchów w notacjach alternatywnych (115)
• 2.3. Stosowanie dokumentu wbudowanego (115)
• 2.4. Określanie długości łańcuchów (118)
• 2.5. Przetwarzanie po jednym wierszu w każdej iteracji (118)
• 2.6. Przetwarzanie po jednym bajcie w każdej iteracji (118)
• 2.7. Stosowanie wyspecjalizowanych technik porównywania łańcuchów (119)
• 2.8. Dzielenie łańcuchów na tokeny (121)
• 2.9. Formatowanie łańcuchów (122)
• 2.10. Stosowanie łańcuchów w roli obiektów wejścia-wyjścia (123)
• 2.11. Konwersja wielkich i małych liter (123)
• 2.12. Uzyskiwanie dostępu i przypisywanie podłańcuchów (125)
• 2.13. Zamiana łańcuchów (127)
• 2.14. Przeszukiwanie łańcuchów (128)
• 2.15. Konwertowanie znaków na kody ASCII (129)
• 2.16. Konwersja jawna i niejawna (129)
• 2.17. Dołączanie elementów do łańcuchów (132)
• 2.18. Usuwanie końcowych znaków nowego wiersza i innych symboli specjalnych (133)
• 2.19. Usuwanie znaków białych z początku i końca łańcucha (134)
• 2.20. Powielanie łańcuchów (134)
• 2.21. Osadzanie wyrażeń w ramach łańcuchów (135)
• 2.22. Opóźnianie przetwarzania łańcuchów (135)
• 2.23. Analiza składniowa danych oddzielonych przecinkami (136)
• 2.24. Konwertowanie łańcuchów na liczby (dziesiętne i inne) (137)
• 2.25. Kodowanie i dekodowanie tekstu szyfrowanego za pomocą metody rot13 (139)
• 2.26. Szyfrowanie łańcuchów (140)
• 2.27. Kompresja łańcuchów (141)
• 2.28. Wyznaczanie liczby wystąpień znaków w łańcuchach (142)
• 2.29. Odwracanie kolejności znaków w łańcuchu (142)
• 2.30. Usuwanie powtarzających się znaków (143)
• 2.31. Usuwanie określonych znaków (143)
• 2.32. Wyświetlanie znaków specjalnych (143)
• 2.33. Generowanie kolejnych łańcuchów (144)
• 2.34. Wyznaczanie 32-bitowych sum CRC (144)
• 2.35. Wyznaczanie kodów MD5 dla łańcuchów (145)
• 2.36. Wyznaczanie odległości Levenshteina dzielącej dwa łańcuchy (146)
• 2.37. Kodowanie i dekodowanie łańcuchów w formacie base64 (148)
• 2.38. Kodowanie i dekodowanie łańcuchów za pomocą narzędzi uuencode oraz uudecode (149)
  
• 2.39. Rozszerzanie i kompresja znaków tabulacji (149)
• 2.40. Opakowywanie wierszy tekstu (150)
• 2.41. Konkluzja (151)

• 3.1. Składnia wyrażeń regularnych (154)
• 3.2. Kompilowanie wyrażeń regularnych (156)
• 3.3. Stosowanie znaków specjalnych (157)
• 3.4. Stosowanie tzw. kotwic (157)
• 3.5. Stosowanie kwantyfikatorów (158)
• 3.6. Antycypacja dodatnia i ujemna (160)
• 3.7. Uzyskiwanie dostępu do referencji wstecznych (161)
• 3.8. Stosowanie klas znaków (165)
• 3.9. Rozszerzone wyrażenia regularne (166)
• 3.10. Dopasowywanie znaku nowego wiersza do kropki (167)
• 3.11. Stosowanie opcji osadzanych (168)
• 3.12. Stosowanie podwyrażeń osadzanych (169)
• 3.13. Ruby i Oniguruma (169)
• 3.13.1. Testowanie dostępności mechanizmu Oniguruma (170)
• 3.13.2. Kompilacja silnika Oniguruma (171)
• 3.13.3. Przegląd wybranych nowości zaimplementowanych w silniku Oniguruma (172)
• 3.13.4. Dodatnia i ujemna antycypacja wsteczna (172)
• 3.13.5. Więcej o kwantyfikatorach (174)
• 3.13.6. Dopasowania nazwane (174)
• 3.13.7. Rekurencja w wyrażeniach regularnych (176)
• 3.14. Kilka przykładowych wyrażeń regularnych (177)
• 3.14.1. Dopasowywanie adresów IP (177)
• 3.14.2. Dopasowywanie par klucz-wartość (178)
• 3.14.3. Dopasowywanie liczb rzymskich (179)
• 3.14.4. Dopasowywanie stałych numerycznych (179)
• 3.14.5. Dopasowywanie łańcuchów zawierających datę i godzinę (180)
• 3.14.6. Wykrywanie powtarzających się wyrazów w tekście (181)
• 3.14.7. Dopasowywanie słów pisanych wielkimi literami (181)
• 3.14.8. Dopasowywanie numerów wersji (182)
• 3.14.9. Kilka dodatkowych wzorców (182)
• 3.15. Konkluzja (183)

• 4.1. Wstęp teoretyczny i terminologia (187)
• 4.2. Kodowanie znaków we współczesnym świecie (po rezygnacji ze standardu ASCII) (191)
• 4.2.1. Biblioteka jcode i zmienna globalna $KCODE (192)
• 4.2.2. Ponowne spojrzenie na popularne operacje na łańcuchach i wyrażeniach regularnych (193)
• 4.2.3. Wykrywanie schematów kodowania znaków (198)
• 4.2.4. Normalizacja łańcuchów Unicode (198)
• 4.2.5. Problemy związane z porządkowaniem łańcuchów (200)
• 4.2.6. Konwertowanie łańcuchów zakodowanych według różnych schematów (204)
• 4.3. Stosowanie katalogów komunikatów (207)
• 4.3.1. Wstęp teoretyczny i terminologia (207)
• 4.3.2. Pierwsze kroki w świecie katalogów komunikatów (208)
• 4.3.3. Lokalizacja prostej aplikacji (209)
• 4.3.4. Informacje dodatkowe (214)
• 4.4. Konkluzja (215)

• 5.1. Reprezentowanie liczb w języku Ruby (218)
• 5.2. Podstawowe operacje na liczbach (219)
• 5.3. Zaokrąglanie liczb zmiennoprzecinkowych (220)
• 5.4. Porównywanie liczb zmiennoprzecinkowych (222)
• 5.5. Formatowanie liczb przeznaczonych do wyświetlenia (223)
• 5.6. Formatowanie liczb z separatorami tysięcy (224)
• 5.7. Praca z bardzo dużymi liczbami całkowitymi (225)
• 5.8. Stosowanie typu BigDecimal (225)
• 5.9. Praca z liczbami wymiernymi (227)
• 5.10. Operacje na macierzach (228)
• 5.11. Praca z liczbami zespolonymi (233)
• 5.12. Stosowanie biblioteki mathn (234)
• 5.13. Rozkład na czynniki pierwsze, największy wspólny dzielnik i najmniejsza wspólna wielokrotność (235)
• 5.14. Praca z liczbami pierwszymi (236)
• 5.15. Niejawna i bezpośrednia konwersja numeryczna (237)
• 5.16. Koercja wartości numerycznych (238)
• 5.17. Wykonywanie operacji bitowych na liczbach (240)
• 5.18. Konwersje pomiędzy systemami liczbowymi (241)
• 5.19. Wyznaczanie pierwiastków sześciennych, czwartego stopnia, piątego stopnia itd. (242)
• 5.20. Określanie porządku bajtów obowiązującego w danej architekturze (243)
  
• 5.21. Numeryczna metoda wyznaczania całki oznaczonej (244)
• 5.22. Trygonometria w stopniach, radianach i gradach (245)
• 5.23. Bardziej zaawansowane funkcje trygonometryczne (247)
• 5.24. Wyznaczanie logarytmów o dowolnych podstawach (247)
• 5.25. Wyznaczanie wartości średniej, mediany i mody zbioru danych (248)
  
• 5.26. Wariancja i odchylenie standardowe (249)
• 5.27. Wyznaczanie współczynnika korelacji (250)
• 5.28. Generowanie liczb losowych (251)
• 5.29. Składowanie wyników funkcji w pamięci podręcznej za pomocą biblioteki memoize (252)
• 5.30. Konkluzja (254)

• 6.1. Symbole (256)
• 6.1.1. Symbole jako typy wyliczeniowe (258)
• 6.1.2. Symbole jako metawartości (258)
• 6.1.3. Symbole, zmienne i metody (259)
• 6.1.4. Konwertowanie na symbole i z symboli (260)
• 6.2. Przedziały (261)
• 6.2.1. Przedziały otwarte i domknięte (262)
• 6.2.2. Wyznaczanie punktów końcowych (262)
• 6.2.3. Iteracyjne przeszukiwanie przedziałów (263)
• 6.2.4. Sprawdzanie przynależności do przedziałów (264)
• 6.2.5. Konwertowanie przedziałów na tablice (264)
• 6.2.6. Przedziały odwrotne (265)
• 6.2.7. Operator przerzutnikowy (265)
• 6.2.8. Przedziały niestandardowe (269)
• 6.3. Konkluzja (272)

• 7.1. Określanie bieżącej godziny (274)
• 7.2. Praca z określonymi datami i godzinami (począwszy od punktu nazywanego epoką) (275)
  
• 7.3. Określanie dnia tygodnia (276)
• 7.4. Określanie daty Wielkanocy (277)
• 7.5. Określanie daty n-tego dnia tygodnia w danym miesiącu (277)
• 7.6. Konwersja pomiędzy sekundami a większymi jednostkami czasu (279)
  
• 7.7. Konwersja daty i godziny do postaci i z postaci epoki (280)
• 7.8. Praca z sekundami przestępnymi - nie róbcie tego w domu! (280)
  
• 7.9. Wyznaczanie numeru dnia w danym roku (281)
• 7.10. Sprawdzanie poprawności daty i godziny (281)
• 7.11. Określanie numeru tygodnia w danym roku (283)
• 7.12. Wykrywanie roku przestępnego (284)
• 7.13. Określanie strefy czasowej (285)
• 7.14. Praca z samymi godzinami i minutami (285)
• 7.15. Porównywanie wartości reprezentujących daty i godziny (285)
• 7.16. Dodawanie i odejmowanie przedziałów czasowych do i od wartości reprezentujących daty i godziny (286)
• 7.17. Wyznaczanie różnic dzielących dwie wartości reprezentujące daty i godziny (287)
• 7.18. Praca z określonymi datami i godzinami (sprzed punktu nazywanego epoką) (287)
  
• 7.19. Wzajemna konwersja obiektów klasy Time, Date oraz DateTime (288)
• 7.20. Odczytywanie daty i godziny z łańcucha wejściowego (289)
• 7.21. Formatowanie i wyświetlanie daty i godziny (291)
• 7.22. Konwersja stref czasowych (292)
• 7.23. Określanie liczby dni danego miesiąca (292)
• 7.24. Dzielenie miesiąca na tygodnie (293)
• 7.25. Konkluzja (294)

• 8.1. Praca z tablicami (296)
• 8.1.1. Tworzenie i inicjalizacja tablic (296)
• 8.1.2. Uzyskiwanie dostępu i przypisywanie wartości elementom tablicy (297)
• 8.1.3. Określanie rozmiaru tablicy (299)
• 8.1.4. Porównywanie tablic (299)
• 8.1.5. Sortowanie elementów tablicy (301)
• 8.1.6. Selekcja elementów tablicy według określonych kryteriów (304)
• 8.1.7. Stosowanie wyspecjalizowanych funkcji indeksujących (306)
• 8.1.8. Implementacja macierzy rzadkich (308)
• 8.1.9. Stosowanie tablic w roli zbiorów matematycznych (309)
• 8.1.10. Losowe porządkowanie elementów tablicy (313)
• 8.1.11. Stosowanie tablic wielowymiarowych (314)
• 8.1.12. Identyfikacja tych elementów jednej tablicy, które nie występują w innej tablicy (315)
• 8.1.13. Transformowanie i odwzorowywanie tablic (315)
• 8.1.14. Usuwanie wartości nil z tablicy (316)
• 8.1.15. Usuwanie określonych elementów tablicy (316)
• 8.1.16. Konkatenacja i dołączanie tablic (317)
• 8.1.17. Stosowanie tablic w roli stosów i kolejek (318)
• 8.1.18. Iteracyjne przeszukiwanie tablic (319)
• 8.1.19. Wstawianie separatorów uwzględnianych w łańcuchu wynikowym (320)
• 8.1.20. Odwracanie kolejności elementów tablicy (320)
• 8.1.21. Usuwanie z tablicy powtarzających się elementów (320)
• 8.1.22. Przeplatanie tablic (321)
• 8.1.23. Zliczanie częstotliwości występowania poszczególnych wartości w tablicy (321)
• 8.1.24. Odwracanie kierunku relacji w tablicy przez tworzenie odpowiedniej tablicy mieszającej (321)
• 8.1.25. Zsynchronizowane sortowanie wielu tablic (322)
• 8.1.26. Określanie wartości domyślnej dla nowych elementów tablicy (323)
• 8.2. Praca z tablicami mieszającymi (324)
• 8.2.1. Tworzenie nowych tablic mieszających (324)
• 8.2.2. Określanie wartości domyślnej dla tablicy mieszającej (325)
• 8.2.3. Uzyskiwanie dostępu i dodawanie par klucz-wartość (326)
• 8.2.4. Usuwanie par klucz-wartość (327)
• 8.2.5. Iteracyjne przeszukiwanie tablicy mieszającej (328)
• 8.2.6. Odwracanie związków w tablicy mieszającej (328)
• 8.2.7. Wykrywanie kluczy i wartości w tablicy mieszającej (329)
• 8.2.8. Konwersja tablic mieszających na tablice (329)
• 8.2.9. Wyodrębnianie par klucz-wartość według określonych kryteriów (330)
• 8.2.10. Sortowanie tablicy mieszającej (330)
• 8.2.11. Scalanie dwóch tablic mieszających (331)
• 8.2.12. Tworzenie tablic mieszających na podstawie tablic (331)
• 8.2.13. Wyznaczanie różnicy i iloczynu (części wspólnej) kluczy zbioru tablic mieszających (331)
• 8.2.14. Stosowanie tablic mieszających w roli reprezentacji macierzy rzadkich (332)
• 8.2.15. Implementacja tablic mieszających obsługujących powtarzające się klucze (333)
• 8.3. Ogólne omówienie typów wyliczeniowych (336)
• 8.3.1. Metoda inject (337)
• 8.3.2. Stosowanie kwalifikatorów (338)
• 8.3.3. Metoda partition (339)
• 8.3.4. Iteracyjne przeszukiwanie kolekcji grupami elementów (340)
• 8.3.5. Konwersja tablic na zbiory (341)
• 8.3.6. Stosowanie obiektów klasy Enumerator (341)
• 8.3.7. Stosowanie obiektów klasy Generator (343)
• 8.4. Konkluzja (344)

• 9.1. Praca ze zbiorami (348)
• 9.1.1. Proste operacje na zbiorach (348)
• 9.1.2. Zaawansowane operacje na zbiorach (350)
• 9.2. Praca ze stosami i kolejkami (351)
• 9.2.1. Implementacja stosu wymuszającego właściwy dostęp do danych (353)
• 9.2.2. Wykrywanie niezbilansowanych znaków interpunkcyjnych w wyrażeniach (354)
• 9.2.3. Stosy i rekurencja (355)
• 9.2.4. Implementacja kolejki wymuszającej właściwy dostęp do danych (357)
• 9.3. Praca z drzewami (358)
• 9.3.1. Implementacja drzewa binarnego (359)
• 9.3.2. Sortowanie danych z wykorzystaniem drzewa binarnego (361)
• 9.3.3. Stosowanie drzewa binarnego w roli tablicy wyszukiwania (363)
• 9.3.4. Konwersja drzewa na łańcuch lub tablicę (364)
• 9.4. Praca z grafami (365)
• 9.4.1. Implementacja grafu w formie macierzy sąsiedztwa (366)
• 9.4.2. Określanie, czy wszystkie węzły grafu są z nim połączone (368)
• 9.4.3. Określanie, czy dany graf zawiera cykl Eulera (370)
• 9.4.4. Określanie, czy dany graf zawiera ścieżkę Eulera (371)
• 9.4.5. Narzędzia ułatwiające operacje na grafach w języku Ruby (371)
• 9.5. Konkluzja (372)

• 10.1. Praca z plikami i katalogami (375)
• 10.1.1. Otwieranie i zamykanie plików (375)
• 10.1.2. Aktualizacja pliku (377)
• 10.1.3. Dopisywanie danych do istniejącego pliku (377)
• 10.1.4. Swobodny dostęp do zawartości plików (377)
• 10.1.5. Praca z plikami binarnymi (378)
• 10.1.6. Blokowanie dostępu do plików (380)
• 10.1.7. Wykonywanie prostych operacji wejścia-wyjścia (381)
• 10.1.8. Wykonywanie buforowanych i niebuforowanych operacji wejścia-wyjścia (382)
• 10.1.9. Modyfikowanie uprawnień dostępu i praw własności do plików (383)
• 10.1.10. Uzyskiwanie i ustawianie informacji o znacznikach czasowych (385)
• 10.1.11. Weryfikacja istnienia i rozmiaru pliku (387)
• 10.1.12. Weryfikacja specjalnych charakterystyk plików (388)
• 10.1.13. Praca z potokami (390)
• 10.1.14. Wykonywanie specjalnych operacji wejścia-wyjścia (392)
• 10.1.15. Stosowanie nieblokujących operacji wejścia-wyjścia (393)
• 10.1.16. Stosowanie metody readpartial (393)
• 10.1.17. Modyfikowanie ścieżek do plików (394)
• 10.1.18. Stosowanie klasy Pathname (395)
• 10.1.19. Wykonywanie operacji na plikach na poziomie poleceń (396)
• 10.1.20. Przechwytywanie znaków z klawiatury (398)
• 10.1.21. Odczytywanie i umieszczanie w pamięci całych plików (399)
• 10.1.22. Iteracyjne przeszukiwanie pliku wejściowego wiersz po wierszu (399)
• 10.1.23. Iteracyjne przeszukiwanie pliku wejściowego bajt po bajcie (400)
• 10.1.24. Traktowanie łańcuchów jak plików (400)
• 10.1.25. Odczytywanie danych osadzonych w kodzie źródłowym programu (401)
• 10.1.26. Odczytywanie kodu źródłowego programu (401)
• 10.1.27. Praca z plikami tymczasowymi (402)
• 10.1.28. Zmienianie i ustawianie katalogu bieżącego (403)
• 10.1.29. Zmiana bieżącego katalogu głównego (403)
• 10.1.30. Iteracyjne przeszukiwanie listy plików i podkatalogów (404)
• 10.1.31. Uzyskiwanie listy plików i podkatalogów (404)
• 10.1.32. Tworzenie łańcucha katalogów (404)
• 10.1.33. Rekurencyjne usuwanie katalogów (405)
• 10.1.34. Odnajdywanie plików i katalogów (405)
• 10.2. Uzyskiwanie dostępu do danych na wyższym poziomie (406)
• 10.2.1. Proste utrwalanie obiektów (406)
• 10.2.2. Bardziej złożone utrwalanie obiektów (408)
• 10.2.3. Sporządzanie "głębokiej kopii" w ograniczonej formie (409)
• 10.2.4. Udoskonalone utrwalanie obiektów za pomocą biblioteki PStore (409)
• 10.2.5. Praca z danymi CSV (411)
• 10.2.6. Utrwalanie danych z wykorzystaniem formatu YAML (413)
• 10.2.7. Przezroczysta architektura utrwalania obiektów za pomocą projektu Madeleine (414)
• 10.2.8. Stosowanie biblioteki DBM (415)
• 10.3. Stosowanie biblioteki KirbyBase (417)
• 10.4. Nawiązywanie połączeń z zewnętrznymi bazami danych (420)
• 10.4.1. Korzystanie z interfejsu bazy danych SQLite (421)
• 10.4.2. Korzystanie z interfejsu bazy danych MySQL (422)
• 10.4.3. Korzystanie z interfejsu bazy danych PostgreSQL (425)
• 10.4.4. Korzystanie z interfejsu do protokołu LDAP (429)
• 10.4.5. Korzystanie z interfejsu bazy danych Oracle (430)
• 10.4.6. Stosowanie opakowania DBI (432)
• 10.4.7. Mechanizmy odwzorowań obiektowo-relacyjnych (433)
• 10.5. Konkluzja (435)

• 11.1. Programowanie obiektowe w codziennej pracy (438)
• 11.1.1. Stosowanie wielu konstruktorów (439)
• 11.1.2. Tworzenie atrybutów egzemplarzy (440)
• 11.1.3. Stosowanie bardziej złożonych konstruktorów (441)
• 11.1.4. Tworzenie atrybutów i metod na poziomie klas (443)
• 11.1.5. Dziedziczenie po nadklasie (447)
• 11.1.6. Testowanie klas obiektów (449)
• 11.1.7. Testowanie równości obiektów (452)
• 11.1.8. Kontrola dostępu do metod (453)
• 11.1.9. Kopiowanie obiektów (455)
• 11.1.10. Stosowanie metody initialize_copy (457)
• 11.1.11. Wyjaśnienie znaczenia metody allocate (458)
• 11.1.12. Praca z modułami (459)
• 11.1.13. Transformowanie i konwertowanie obiektów (462)
• 11.1.14. Tworzenie klas (struktur) zawierających wyłącznie dane (466)
• 11.1.15. Zamrażanie obiektów (467)
• 11.2. Techniki zaawansowane (469)
• 11.2.1. Wysyłanie obiektom komunikatów wyrażonych wprost (469)
• 11.2.2. Specjalizacja pojedynczych obiektów (471)
• 11.2.3. Zagnieżdżanie klas i modułów (475)
• 11.2.4. Tworzenie klas parametrycznych (476)
• 11.2.5. Stosowanie kontynuacji w implementacji generatora (479)
• 11.2.6. Składowanie kodu w formie obiektów (481)
• 11.2.7. Omówienie mechanizmu zawierania modułów (483)
• 11.2.8. Wykrywanie parametrów domyślnych (485)
• 11.2.9. Delegowanie wywołań i przekazywanie ich dalej (486)
• 11.2.10. Automatyczne definiowanie metod odczytujących i zapisujących na poziomie klasy (488)
• 11.2.11. Stosowanie zaawansowanych technik programistycznych (490)
• 11.3. Praca z elementami dynamicznymi języka Ruby (493)
• 11.3.1. Dynamiczne przetwarzanie kodu (494)
• 11.3.2. Stosowanie metody const_get (495)
• 11.3.3. Dynamiczne tworzenie egzemplarzy klasy reprezentowanej przez nazwę (496)
• 11.3.4. Zwracanie i ustawianie zmiennych egzemplarzy (497)
• 11.3.5. Stosowanie wyrażenia define_method (498)
• 11.3.6. Stosowanie metody const_missing (502)
• 11.3.7. Usuwanie definicji (503)
• 11.3.8. Generowanie list zdefiniowanych konstrukcji (505)
• 11.3.9. Analiza stosu wywołań (507)
• 11.3.10. Monitorowanie wykonywania programu (508)
• 11.3.11. Przeszukiwanie przestrzeni obiektów (510)
• 11.3.12. Obsługa wywołań nieistniejących metod (510)
• 11.3.13. Śledzenie zmian w definicji klasy lub obiektu (511)
• 11.3.14. Definiowanie finalizatorów obiektów (515)
• 11.4. Konkluzja (517)

• 12.1. Ruby i Tk (520)
• 12.1.1. Wprowadzenie (521)
• 12.1.2. Prosta aplikacja okienkowa (522)
• 12.1.3. Praca z przyciskami (524)
• 12.1.4. Praca z polami tekstowymi (528)
• 12.1.5. Praca z pozostałymi rodzajami kontrolek (532)
• 12.1.6. Informacje dodatkowe (536)
• 12.2. Ruby i GTK2 (537)
• 12.2.1. Wprowadzenie (537)
• 12.2.2. Prosta aplikacja okienkowa (538)
• 12.2.3. Praca z przyciskami (540)
• 12.2.4. Praca z polami tekstowymi (542)
• 12.2.5. Praca z pozostałymi rodzajami kontrolek (545)
• 12.2.6. Informacje dodatkowe (550)
• 12.3. FXRuby (FOX) (553)
• 12.3.1. Wprowadzenie (553)
• 12.3.2. Prosta aplikacja okienkowa (555)
• 12.3.3. Praca z przyciskami (556)
• 12.3.4. Praca z polami tekstowymi (558)
• 12.3.5. Praca z pozostałymi rodzajami kontrolek (560)
• 12.3.6. Informacje dodatkowe (569)
• 12.4. QtRuby (570)
• 12.4.1. Wprowadzenie (570)
• 12.4.2. Prosta aplikacja okienkowa (571)
• 12.4.3. Praca z przyciskami (572)
• 12.4.4. Praca z polami tekstowymi (574)
• 12.4.5. Praca z pozostałymi rodzajami kontrolek (576)
• 12.4.6. Informacje dodatkowe (581)
• 12.5. Pozostałe zestawy narzędzi GUI (582)
• 12.5.1. Ruby i środowisko X (582)
• 12.5.2. Ruby i system wxWidgets (583)
• 12.5.3. Apollo (Ruby i Delphi) (583)
• 12.5.4. Ruby i interfejs Windows API (584)
• 12.6. Konkluzja (584)

• 13.1. Tworzenie wątków i zarządzanie nimi (586)
• 13.1.1. Tworzenie wątków (587)
• 13.1.2. Uzyskiwanie dostępu do zmiennych lokalnych wątków (588)
• 13.1.3. Sprawdzanie i modyfikowanie stanu wątku (590)
• 13.1.4. Oczekiwanie na wątek potomny (i przechwytywanie zwracanej wartości) (593)
• 13.1.5. Obsługa wyjątków (595)
• 13.1.6. Stosowanie grup wątków (596)
• 13.2. Synchronizacja wątków (597)
• 13.2.1. Proste synchronizowanie wątków z wykorzystaniem sekcji krytycznych (599)
• 13.2.2. Synchronizacja dostępu do zasobów (biblioteka mutex.rb) (600)
• 13.2.3. Stosowanie predefiniowanych klas kolejek synchronizowanych (604)
• 13.2.4. Stosowanie zmiennych warunkowych (605)
• 13.2.5. Stosowanie pozostałych technik synchronizacji (607)
• 13.2.6. Stosowanie limitów czasowych dla operacji (610)
• 13.2.7. Oczekiwanie na zdarzenia (611)
• 13.2.8. Kontynuacja przetwarzania w czasie wykonywania operacji wejścia-wyjścia (612)
• 13.2.9. Implementacja iteratorów równoległych (613)
• 13.2.10. Rekurencyjne, równoległe usuwanie plików i katalogów (615)
• 13.3. Konkluzja (616)

• 14.1. Uruchamianie programów zewnętrznych (618)
• 14.1.1. Stosowanie metod system i exec (618)
• 14.1.2. Przechwytywanie danych wyjściowych wykonywanego polecenia (620)
• 14.1.3. Operacje na procesach (621)
• 14.1.4. Operacje na standardowym wejściu-wyjściu (624)
• 14.2. Opcje i argumenty wiersza poleceń (624)
• 14.2.1. Analiza składniowa opcji wiersza poleceń (625)
• 14.2.2. Stała ARGF (627)
• 14.2.3. Stała ARGV (628)
• 14.3. Biblioteka Shell (629)
• 14.3.1. Przekierowywanie wejścia-wyjścia za pomocą klasy Shell (629)
• 14.3.2. Informacje dodatkowe o bibliotece shell.rb (631)
• 14.4. Uzyskiwanie dostępu do zmiennych środowiskowych (632)
• 14.4.1. Odczytywanie i ustawianie wartości zmiennych środowiskowych (632)
• 14.4.2. Składowanie zmiennych środowiskowych w formie tablic lub tablic mieszających (633)
• 14.4.3. Importowanie zmiennych środowiskowych do postaci zmiennych globalnych aplikacji (634)
• 14.5. Wykonywanie skryptów w systemach Microsoft Windows (635)
• 14.5.1. Stosowanie biblioteki Win32API (636)
• 14.5.2. Stosowanie biblioteki Win32OLE (637)
• 14.5.3. Stosowanie interfejsu ActiveScriptRuby (640)
• 14.6. Wygodny instalator dla systemu Windows (641)
• 14.7. Biblioteki, które warto znać (643)
• 14.8. Praca z plikami, katalogami i drzewami (644)
• 14.8.1. Kilka słów o filtrach tekstu (644)
• 14.8.2. Kopiowanie drzewa katalogów (obejmującego dowiązania symetryczne) (645)
• 14.8.3. Usuwanie plików według wieku i innych kryteriów (647)
• 14.8.4. Określanie ilości wolnej przestrzeni na dysku (648)
• 14.9. Rozmaite zadania realizowane za pomocą skryptów (648)
• 14.9.1. Programy języka Ruby w formie pojedynczych plików (649)
• 14.9.2. Kierowanie potoku do interpretera języka Ruby (650)
• 14.9.3. Uzyskiwanie i ustawianie kodów wyjścia (651)
• 14.9.4. Sprawdzanie, czy dany program pracuje w trybie interaktywnym (652)
• 14.9.5. Określanie bieżącej platformy lub systemu operacyjnego (652)
• 14.9.6. Stosowanie modułu Etc (653)
• 14.10. Konkluzja (654)

• 15.1. Analiza składniowa danych w formacie XML za pomocą biblioteki REXML (656)
• 15.1.1. Analiza składniowa z wykorzystaniem struktury drzewa (658)
• 15.1.2. Analiza składniowa danych w formie strumienia (659)
• 15.1.3. Język XPath i inne (660)
• 15.2. Praca z formatami RSS i Atom (661)
• 15.2.1. Biblioteka standardowa rss (661)
• 15.2.2. Biblioteka feedtools (664)
• 15.3. Operowanie na obrazach za pośrednictwem biblioteki RMagick (666)
• 15.3.1. Typowe operacje na obrazach (667)
• 15.3.2. Przekształcenia i efekty specjalne (670)
• 15.3.3. Interfejs API umożliwiający rysowanie (672)
• 15.4. Tworzenie dokumentów PDF za pomocą biblioteki PDF::Writer (677)
  
  • 15.4.1. Podstawowe pojęcia i techniki (677)
  • 15.4.2. Dokument przykładowy (679)
• 15.5. Konkluzja (687)

• 16.1. Testowanie aplikacji za pomocą biblioteki Test::Unit (690)
• 16.2. Narzędzia ZenTest (695)
• 16.3. Stosowanie debugera języka Ruby (698)
• 16.4. Stosowanie narzędzia irb w roli debugera programów napisanych w Ruby (701)
• 16.5. Ocena pokrycia kodu testami (703)
• 16.6. Ocena wydajności (704)
• 16.7. Stosowanie techniki pretty-printing dla obiektów (709)
• 16.8. Konkluzja (711)

• 17.1. Stosowanie narzędzia RDoc (714)
• 17.1.1. Stosowanie znaczników formatujących (715)
• 17.1.2. Bardziej zaawansowane techniki formatowania (719)
• 17.2. Instalacja i pakowanie (720)
• 17.2.1. Biblioteka setup.rb (720)
• 17.2.2. System RubyGems (723)
• 17.3. Projekty RubyForge i RAA (724)
• 17.4. Konkluzja (727)

• 18.1. Serwery sieciowe (731)
• 18.1.1. Prosty serwer - która godzina? (732)
• 18.1.2. Implementacja serwera wielowątkowego (734)
• 18.1.3. Studium przypadku: serwer szachowy pracujący w trybie równorzędnym (734)
• 18.2. Aplikacje klienckie (743)
• 18.2.1. Uzyskiwanie za pośrednictwem internetu prawdziwych liczb losowych (744)
• 18.2.2. Nawiązywanie połączeń z oficjalnym serwerem czasu (747)
• 18.2.3. Komunikacja z serwerem POP (748)
• 18.2.4. Wysyłanie wiadomości poczty elektronicznej za pośrednictwem protokołu SMTP (750)
• 18.2.5. Komunikacja z serwerem IMAP (753)
• 18.2.6. Kodowanie i dekodowanie załączników (756)
• 18.2.7. Studium przypadku: brama łącząca listę dyskusyjną z grupą dyskusyjną (758)
• 18.2.8. Uzyskiwanie strony internetowej na podstawie adresu URL (763)
• 18.2.9. Stosowanie biblioteki Open-URI (764)
• 18.3. Konkluzja (765)

• 19.1. Programowanie w języku Ruby aplikacji CGI (767)
• 19.1.1. Wprowadzenie do biblioteki cgi.rb (769)
• 19.1.2. Wyświetlanie i przetwarzanie formularzy (771)
• 19.1.3. Praca ze znacznikami kontekstu klienta (772)
• 19.1.4. Praca z sesjami użytkownika (773)
• 19.2. Stosowanie technologii FastCGI (774)
• 19.3. Framework Ruby on Rails (776)
• 19.3.1. Podstawowe zasady i techniki programowania (777)
• 19.3.2. Testowanie i diagnozowanie aplikacji budowanych na bazie frameworku Rails (779)
• 19.3.3. Rozszerzenia zbioru klas podstawowych (780)
• 19.3.4. Narzędzia i biblioteki pokrewne (781)
• 19.4. Wytwarzanie aplikacji internetowych z wykorzystaniem zestawu narzędzi Nitro (782)
• 19.4.1. Tworzenie prostych aplikacji na bazie zestawu narzędzi Nitro (783)
• 19.4.2. Zestaw narzędzi Nitro i wzorzec projektowy MVC (785)
• 19.4.3. Nitro i mechanizm Og (790)
• 19.4.4. Realizacja typowych zadań budowy aplikacji internetowych z wykorzystaniem zestawu narzędzi Nitro (791)
• 19.4.5. Informacje dodatkowe (795)
• 19.5. Wprowadzenie do frameworku Wee (797)
• 19.5.1. Prosty przykład (798)
• 19.5.2. Wiązanie stanu z adresami URL (799)
• 19.6. Wytwarzanie aplikacji internetowych z wykorzystaniem frameworku IOWA (801)
• 19.6.1. Podstawowe cechy frameworku IOWA (801)
• 19.6.2. Stosowanie szablonów w aplikacjach budowanych na bazie frameworku IOWA (804)
• 19.6.3. Transfer sterowania pomiędzy komponentami (805)
• 19.7. Ruby i serwery WWW (807)
• 19.7.1. Stosowanie modułu mod_ruby (808)
• 19.7.2. Stosowanie narzędzia erb (809)
• 19.7.3. Stosowanie serwera WEBrick (812)
• 19.7.4. Stosowanie serwera Mongrel (814)
• 19.8. Konkluzja (817)

• 20.1. Wprowadzenie do biblioteki drb (820)
• 20.2. Studium przypadku: symulacja systemu publikacji aktualnych notowań papierów wartościowych (823)
• 20.3. Biblioteka Rinda: przestrzeń krotek języka Ruby (827)
• 20.4. Wyszukiwanie usług za pomocą mechanizmów rozproszonych języka Ruby (832)
• 20.5. Konkluzja (833)

• 21.1. Stosowanie systemu RubyGems (836)
• 21.2. Narzędzie rake (838)
• 21.3. Stosowanie narzędzia irb (843)
• 21.4. Narzędzie ri (848)
• 21.5. Edytory kodu (849)
• 21.6. Zintegrowane środowiska wytwarzania (851)
• 21.7. Konkluzja (852)

• 22.1. Zasoby internetowe (855)
• 22.2. Grupy i listy dyskusyjne (856)
• 22.3. Blogi i czasopisma internetowe (857)
• 22.4. Dokumenty RCR (857)
• 22.5. Kanały IRC (858)
• 22.6. Konferencje poświęcone programowaniu w Ruby (859)
• 22.7. Lokalne grupy programistów Ruby (860)
• 22.8. Konkluzja (860)