• Jak rozpocząć przygodę z językiem Ruby?
• Jak wykorzystać drzemiące w nim możliwości?
• Jak zwiększyć elastyczność tworzonego kodu za pomocą wzorców projektowych?

Stworzony w 1995 roku przez Yukihiro Matsumoto język Ruby dzięki swym unikalnym możliwościom zdobywa serca programistów na całym świecie. Cechy, które podbijają to nieufne środowisko, to między innymi prosta składnia z wbudowanymi w nią wyrażeniami regularnymi, automatyczne oczyszczanie pamięci i wiele, wiele innych. Ogromna i chętna do pomocy społeczność czyni to rozwiązanie jeszcze bardziej atrakcyjnym. Ruby pozwala na korzystanie ze wzorców projektowych - zbioru zasad i reguł prowadzących do celu w najlepszy, najszybszy i najbardziej elastyczny sposób.

Wzorce projektowe kojarzą się głównie z językami Java oraz C i C++. Książka "Ruby. Wzorce projektowe" pokazuje, że można ich z powodzeniem używać również w języku Ruby. Dowiesz się z niej, w jaki sposób wykorzystać znane wzorce, takie jak Observer, Singleton czy też Proxy. Autor przedstawi Ci również nowe wzorce, które ze względu na cechy języka Ruby mogą zostać w nim zastosowane. Jednak zanim przejdziesz do ich omawiania, Russ poprowadzi Cię przez podstawy programowania w tym języku. Nauczysz się używać między innymi pętli, instrukcji warunkowych, wyrażeń regularnych. Niewątpliwie Twoją ciekawość wzbudzi tak zwany "duck typing", który oczywiście także został dokładnie tu omówiony. Russ Olsen dzięki swojemu wieloletniemu doświadczeniu każdy wzorzec ilustruje przykładem z życia wziętym. Ułatwi Ci to przyswojenie i zastosowanie we własnych projektach przedstawionych tu wzorców.

• Podstawy programowania w języku Ruby
• Zastosowanie wzorców - takich jak Observer, Composite, Iterator, Command i wiele innych
• Wykorzystanie technik metaprogramowania do tworzenia obiektów niestandardowych
• Wykorzystanie wyrażeń regularnych
• Użycie języków dziedzinowych
• Sposób instalacji języka Ruby

Osoby które kupowały "Ruby. Wzorce projektowe", wybierały także:

• Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
• Programowanie w Ruby. Poziom drugi. Kurs video. Zaawansowane techniki 69,00 zł, (27,60 zł -60%)
• Ruby on Rails (RoR). Kurs video. Programowanie aplikacji internetowych 99,00 zł, (44,55 zł -55%)
• Ruby. Kurs video. Poziom pierwszy. Podstawy języka i praktyczne przykłady 79,00 zł, (35,55 zł -55%)
• Ruby on Rails. Kurs video. Wdrażanie (deployment) na własne serwery i chmurę 59,00 zł, (26,55 zł -55%)

Spis treści

Ruby. Wzorce projektowe -- spis treści

Słowo wstępne (15)

Przedmowa (19)

Podziękowania (25)

O autorze (27)

CZĘŚĆ I: WZORCE PROJEKTOWE I RUBY (29)

Rozdział 1. Budowa lepszych programów z wykorzystaniem wzorców projektowych (31)

• Banda Czworga (32)
  
• Wzorce dla wzorców (33)
  
  • Oddzielaj elementy zmienne od elementów stałych (33)
  • Programuj pod kątem interfejsu, nie implementacji (34)
  • Stosuj kompozycję zamiast dziedziczenia (36)
  • Deleguj, deleguj i jeszcze raz deleguj (40)
  • Czy dane rozwiązanie rzeczywiście jest niezbędne (41)
• Czternaście z dwudziestu trzech (43)
  
• Wzorce projektowe w języku Ruby? (45)

Rozdział 2. Pierwsze kroki w języku Ruby (47)

• Interaktywny język Ruby (48)
  
• Przywitaj się ze światem (48)
  
• Zmienne (51)
  
• Typy Fixnum i Bignum (52)
  
• Liczby zmiennoprzecinkowe (53)
  
• W języku Ruby nie ma typów prostych (54)
  
• Kiedy brakuje obiektów... (55)
  
• Prawda, fałsz i nil (55)
  
• Decyzje, decyzje (57)
  
• Pętle (58)
  
• Więcej o łańcuchach (60)
  
• Symbole (63)
  
• Tablice (63)
  
• Tablice mieszające (65)
  
• Wyrażenia regularne (65)
  
• Nasza pierwsza klasa (66)
  
• Operacje na zmiennych egzemplarzy (68)
  
• Obiekt pyta: Kim jestem? (70)
  
• Dziedziczenie, podklasy i nadklasy (71)
  
• Opcje argumentów (72)
  
• Moduły (73)
  
• Wyjątki (76)
  
• Wątki (77)
  
• Zarządzanie odrębnymi plikami z kodem źródłowym (78)
  
• Podsumowanie (79)

CZĘŚĆ II: WZORCE PROJEKTOWE W JĘZYKU RUBY (81)

Rozdział 3. Urozmaicanie algorytmów za pomocą wzorca projektowego Template Method (83)

• Jak stawić czoło typowym problemom (84)
  
• Izolowanie elementów zachowujących dotychczasową formę (85)
  
• Odkrywanie wzorca projektowego Template Method (88)
  
• Metody zaczepienia (89)
  
• Gdzie się właściwie podziały wszystkie te deklaracje? (92)
  
• Typy, bezpieczeństwo i elastyczność (93)
  
• Testy jednostkowe nie mają charakteru opcjonalnego (95)
  
• Używanie i nadużywanie wzorca projektowego Template Method (97)
  
• Szablony w praktycznych zastosowaniach (98)
  
• Podsumowanie (99)

Rozdział 4. Zastępowanie algorytmu strategią (101)

• Deleguj, deleguj i jeszcze raz deleguj (102)
  
• Współdzielenie danych przez kontekst i strategię (104)
  
• Jeszcze raz o kaczym typowaniu (106)
  
• Obiekty Proc i bloki kodu (107)
  
• Krótka analiza kilku prostych strategii (111)
  
• Używanie i nadużywanie wzorca projektowego Strategy (112)
  
• Wzorzec Strategy w praktycznych zastosowaniach (113)
  
• Podsumowanie (114)

Rozdział 5. Jak być na bieżąco dzięki wzorcowi Observer (117)

• Trzymamy rękę na pulsie (117)
  
• Jak skuteczniej trzymać rękę na pulsie? (119)
  
• Wyodrębnianie mechanizmu umożliwiającego obserwację (122)
  
• Stosowanie bloków kodu w roli obserwatorów (125)
  
• Odmiany wzorca projektowego Observer (126)
  
• Używanie i nadużywanie wzorca projektowego Observer (127)
  
• Wzorzec Observer w praktycznych zastosowaniach (129)
  
• Podsumowanie (130)

Rozdział 6. Budowa większej całości z części za pomocą wzorca Composite (133)

• Całość i części (134)
  
• Tworzenie kompozytów (136)
  
• Doskonalenie implementacji wzorca Composite z wykorzystaniem operatorów (140)
  
• A może tablica w roli kompozytu? (141)
  
• Kłopotliwe różnice (141)
  
• Wskaźniki w obie strony (142)
  
• Używanie i nadużywanie wzorca projektowego Composite (143)
  
• Kompozyty w praktycznych zastosowaniach (145)
  
• Podsumowanie (147)

Rozdział 7. Przeszukiwanie kolekcji z wykorzystaniem wzorca Iterator (149)

• Iteratory zewnętrzne (149)
  
• Iteratory wewnętrzne (152)
  
• Iteratory wewnętrzne kontra iteratory wewnętrzne (153)
  
• Niezrównany moduł Enumerable (154)
  
• Używanie i nadużywanie wzorca projektowego Iterator (156)
  
• Iteratory w praktycznych zastosowaniach (158)
  
• Podsumowanie (161)

Rozdział 8. Doprowadzanie spraw do końca za pomocą wzorca Command (163)

• Eksplozja podklas (164)
  
• Prostsze rozwiązanie (165)
  
• Stosowanie bloków kodu w roli poleceń (166)
  
• Rejestrowanie poleceń (167)
  
• Wycofywanie operacji za pomocą wzorca Command (170)
  
• Kolejkowanie poleceń (173)
  
• Używanie i nadużywanie wzorca projektowego Command (174)
  
• Wzorzec projektowy Command w praktycznych zastosowaniach (175)
  
  • Migracje w ramach interfejsu ActiveRecord (175)
  • Madeleine (176)
• Podsumowanie (179)

Rozdział 9. Wypełnianie luk z wykorzystaniem wzorca Adapter (181)

• Adaptery programowe (182)
  
• Minimalne niedociągnięcia (184)
  
• Czy alternatywą może być adaptowanie istniejących klas? (186)
  
• Modyfikowanie pojedynczych obiektów (187)
  
• Adaptować czy modyfikować? (188)
  
• Używanie i nadużywanie wzorca projektowego Adapter (190)
  
• Adaptery w praktycznych zastosowaniach (190)
  
• Podsumowanie (191)

Rozdział 10. Tworzenie zewnętrznego reprezentanta naszego obiektu z wykorzystaniem wzorca Proxy (193)

• Rozwiązaniem są pośrednicy (194)
  
• Pośrednik ochrony (196)
  
• Pośrednicy zdalni (197)
  
• Pośrednicy wirtualni jako środek rozleniwiający (198)
  
• Eliminacja najbardziej uciążliwych elementów implementacji pośredników (200)
  
  • Metody i przekazywanie komunikatów (201)
  • Metoda method_missing (202)
  • Wysyłanie komunikatów (203)
  • Bezbolesne implementowanie pośredników (203)
• Używanie i nadużywanie pośredników (206)
  
• Wzorzec Proxy w praktycznych zastosowaniach (207)
  
• Podsumowanie (208)

Rozdział 11. Doskonalenie obiektów za pomocą wzorca Decorator (211)

• Dekoratory: lekarstwo na brzydki kod (212)
  
• Dekoracja formalna (217)
  
• Jak uprościć model delegacji zadań (218)
  
• Dynamiczna alternatywa dla wzorca projektowego Decorator (219)
  
  • Opakowywanie metod (219)
  • Dekorowanie za pomocą modułów (220)
• Używanie i nadużywanie wzorca projektowego Decorator (221)
  
• Dekoratory w praktycznych zastosowaniach (222)
  
• Podsumowanie (223)

Rozdział 12. Jak zyskać pewność, że to ten jedyny, z wykorzystaniem wzorca Singleton (225)

• Jeden obiekt, dostęp globalny (225)
  
• Zmienne i metody klasowe (226)
  
  • Zmienne klasowe (226)
  • Metody klasowe (227)
• Pierwsza próba opracowania singletonu w Ruby (228)
  
  • Zarządzanie jedynym obiektem (229)
  • Upewnianie się, że istnieje tylko jeden (230)
• Moduł Singleton (231)
  
• Singletony leniwe i chciwe (232)
  
• Konstrukcje alternatywne względem klasycznego singletonu (232)
  
  • Zmienne globalne jako singletony (232)
  • Klasy jako singletony (233)
  • Moduły jako singletony (235)
• Pasy bezpieczeństwa kontra kaftan bezpieczeństwa (236)
  
• Używanie i nadużywanie wzorca projektowego Singleton (237)
  
  • Czy singletony nie są przypadkiem zwykłymi zmiennymi globalnymi? (237)
  • Właściwie iloma singletonami dysponujemy? (238)
  • Singletony i niezbędna wiedza (238)
  • Eliminowanie utrudnień związanych z testowaniem (240)
• Singletony w praktycznych zastosowaniach (241)
  
• Podsumowanie (242)

Rozdział 13. Wybór właściwej klasy za pomocą wzorca Factory (243)

• Inny rodzaj kaczego typowania (244)
  
• Powrót wzorca projektowego Template Method (246)
  
• Sparametryzowane metody wytwórcze (248)
  
• Klasy to po prostu obiekty (251)
  
• Złe wieści: nasz program podbił świat (252)
  
• Grupowe tworzenie obiektów (253)
  
• Klasy to po prostu obiekty (raz jeszcze) (255)
  
• Korzystanie z nazw (257)
  
• Używanie i nadużywanie wzorców fabryk (258)
  
• Wzorce fabryk w praktycznych zastosowaniach (258)
  
• Podsumowanie (260)

Rozdział 14. Uproszczone konstruowanie obiektów z wykorzystaniem wzorca Builder (263)

• Budowa komputerów (264)
  
• Klasy budowniczych polimorficznych (267)
  
• Klasy budowniczych mogą też zapewnić bezpieczeństwo tworzenia obiektów (270)
  
• Klasy budowniczych wielokrotnego użytku (270)
  
• Lepsza implementacja budowniczych z wykorzystaniem magicznych metod (271)
  
• Używanie i nadużywanie wzorca projektowego Builder (272)
  
• Klasy budowniczych w praktycznych zastosowaniach (273)
  
• Podsumowanie (274)

Rozdział 15. Łączenie systemu z wykorzystaniem interpretera (275)

• Język dostosowany do realizowanego zadania (276)
  
• Konstruowanie interpretera (277)
  
• Interpreter odnajdywania plików (279)
  
  • Odnajdywanie wszystkich plików (279)
  • Wyszukiwanie plików według nazw (280)
  • Wielkie pliki i pliki zapisywalne (281)
  • Bardziej złożone operacje wyszukiwania z uwzględnieniem logicznej negacji, koniunkcji i alternatywy (282)
• Tworzenie drzewa AST (284)
  
  • Prosty analizator składniowy (284)
  • Interpreter bez analizatora składniowego? (286)
  • Analiza składniowa danych języka XML czy YAML? (287)
  • Generowanie złożonych analizatorów składniowych za pomocą narzędzia Racc (288)
  • A może wykorzystać analizator samego języka Ruby? (288)
• Używanie i nadużywanie wzorca projektowego Interpreter (289)
  
• Interpretery w praktycznych zastosowaniach (290)
  
• Podsumowanie (291)

CZĘŚĆ III: WZORCE DLA JĘZYKA RUBY (293)

Rozdział 16. Otwieranie systemów za pomocą języków dziedzinowych (DSL) (295)

• Języki dziedzinowe (296)
  
• Język DSL kopii zapasowej (297)
  
• Czy to plik z danymi? Nie, to program! (297)
  
• Budowa języka PackRat (299)
  
• Łączenie opracowanych dotychczas elementów w jedną całość (300)
  
• Krytyczne spojrzenie na język PackRat (301)
  
• Doskonalenie języka PackRat (302)
  
• Używanie i nadużywanie wewnętrznych języków DSL (305)
  
• Wewnętrzne języki DSL w praktycznych zastosowaniach (305)
  
• Podsumowanie (307)

Rozdział 17. Tworzenie niestandardowych obiektów techniką metaprogramowania (309)

• Obiekty szyte na miarę metoda po metodzie (310)
  
• Obiekty niestandardowe tworzone moduł po module (312)
  
• Wyczarowywanie zupełnie nowych metod (313)
  
• Rzut okiem na wewnętrzną strukturę obiektu (317)
  
• Używanie i nadużywanie metaprogramowania (318)
  
• Metaprogramowanie w praktycznych zastosowaniach (319)
  
• Podsumowanie (322)

Rozdział 18. Konwencja ponad konfiguracją (323)

• Interfejs użytkownika dobry dla... programistów (325)
  
  • Przewidywanie przyszłych potrzeb (326)
  • Oszczędźmy użytkownikom powtarzania swojej woli (326)
  • Udostępnianie szablonów (327)
• Bramka wiadomości (327)
  
• Wybór adaptera (329)
  
• Ładowanie klas (331)
  
• Dodanie prostych zabezpieczeń (333)
  
• Ułatwianie użytkownikowi wejścia w świat naszego oprogramowania (335)
  
• Podsumowanie przykładu bramki wiadomości (336)
  
• Używanie i nadużywanie wzorca projektowego Convention Over Configuration (337)
  
• Wzorzec Convention Over Configuration w praktycznych zastosowaniach (338)
  
• Podsumowanie (339)

Rozdział 19. Konkluzja (341)

DODATKI (345)

Dodatek A: Instalacja języka Ruby (347)

• Instalacja Ruby w systemie Microsoft Windows (347)
  
• Instalacja Ruby w systemie Linux i pozostałych systemach wywodzących się z systemu UNIX (348)
  
• System Mac OS X (348)

Dodatek B: Pogłębiona analiza (349)

• Wzorce projektowe (349)
  
• Ruby (350)
  
• Wyrażenia regularne (352)
  
• Blogi i witryny internetowe (352)

Skorowidz (353)