Zbiór gotowych rozwiązań i porad dla programistów Ruby

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

• 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

Spis treści:

Słowo wstępne (21)

Podziękowania (25)

O autorze (29)

Wprowadzenie (31)

Rozdział 1. Przegląd języka Ruby (47)

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

Rozdział 2. Praca z łańcuchami (113)

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

Rozdział 3. Praca z wyrażeniami regularnymi (153)

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

Rozdział 4. Umiędzynaradawianie aplikacji Ruby (185)

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

Rozdział 5. Wykonywanie obliczeń numerycznych (217)

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

Rozdział 6. Symbole i przedziały (255)

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

Rozdział 7. Praca z datami i godzinami (273)

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

Rozdział 8. Tablice, tablice mieszające i inne wyliczeniowe struktury danych (295)

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

Rozdział 9. Zaawansowane struktury danych (347)

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

Rozdział 10. Operacje wejścia-wyjścia i techniki składowania danych (373)

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

Rozdział 11. Programowanie obiektowe i dynamiczne elementy języka Ruby (437)

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

Rozdział 12. Interfejsy graficzne dla Ruby (519)

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

Rozdział 13. Wątki w języku Ruby (585)

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

Rozdział 14. Tworzenie skryptów i administracja systemem (617)

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

Rozdział 15. Ruby i formaty danych (655)

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

Rozdział 16. Testowanie i diagnozowanie oprogramowania (689)

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

Rozdział 17. Pakowanie i dystrybucja kodu źródłowego (713)

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

Rozdział 18. Programowanie rozwiązań sieciowych (729)

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

Rozdział 19. Ruby i aplikacje internetowe (767)

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

Rozdział 20. Implementacja aplikacji rozproszonych w Ruby (819)

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

Rozdział 21. Narzędzia wytwarzania oprogramowania w Ruby (835)

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

Rozdział 22. Społeczność programistów języka Ruby (855)

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

Skorowidz (861)