Poznaj możliwości Ruby!

• Jak rozpocząć przygodę z Ruby?
• Jakie możliwości daje Ruby on Rails?
• Jak wykorzystać bazy danych w tym języku?

• Przygotowanie środowiska pracy
• Podstawowe zagadnienia z dziedziny programowania obiektowego
• Składnia i konstrukcje języka Ruby
• Sterowanie przepływem
• Tworzenie dokumentacji
• Obsługa błędów, testowanie i debugowanie aplikacji
• Obsługa plików
• Wykorzystanie baz danych
• Możliwości i zastosowanie Ruby on Rails
• Wykorzystanie zasobów sieci Internet w Ruby
• Obsługa sieci, gniazd i demonów
• Przydatne pakiety i biblioteki w Ruby

Spis treści:

• Instalowanie języka Ruby (30)
  
  • Windows (30)
  • Apple Mac OS X (33)
  • Linux (35)
  • Inne platformy (37)
• Podsumowanie (39)

• Pierwsze kroki (42)
  
  • irb: interaktywny Ruby (42)
  • Ruby to angielski dla komputerów (43)
  • Dlaczego Ruby jest doskonałym językiem programowania? (43)
  • Ścieżki umysłu (44)
• Zapisywanie pomysłów w kodzie źródłowym języka Ruby (46)
  
  • Jak Ruby interpretuje rzeczy za pomocą obiektów i klas (47)
  • Tworzenie osoby (47)
  • Podstawowe zmienne (49)
  • Od osób do zwierząt (50)
• Wszystko jest obiektem (53)
  
  • Metody klasy Kernel (55)
  • Przekazywanie danych do metod (55)
  • Metody klasy String (56)
• Korzystanie z języka Ruby z pominięciem orientacji obiektowej (58)
  
• Podsumowanie (59)

• Liczby i wyrażenia (61)
  
  • Podstawowe wyrażenia (62)
  • Zmienne (62)
  • Operatory i wyrażenia porównywania (64)
  • Iterowanie przez liczby przy użyciu bloków i iteratorów (65)
  • Liczby zmiennoprzecinkowe (67)
  • Stałe (68)
• Tekst i ciągi znaków (69)
  
  • Literały ciągów znaków (69)
  • Wyrażenia z ciągami znaków (71)
  • Interpolacja (72)
  • Metody klasy String (73)
  • Wyrażenia regularne i manipulowanie ciągami znaków (74)
• Tablice i listy (80)
  
  • Tablice podstawowe (80)
  • Dzielenie ciągów znaków na tablice (82)
  • Iterowanie w tablicy (83)
  • Inne metody stosowane do działania na tablicach (84)
• Tablice asocjacyjne (86)
  
  • Podstawowe metody do obsługi tablic asocjacyjnych (86)
  • Tablice asocjacyjne z tablicami asocjacyjnymi (88)
• Przepływ sterowania (89)
  
  • Instrukcje if i unless (89)
  • Operator trójargumentowy ?: (90)
  • Instrukcje elsif oraz case (91)
  • Instrukcje while i until (92)
  • Bloki kodu (93)
• Inne przydatne konstrukcje (95)
  
  • Daty i czas (95)
  • Duże liczby (98)
  • Zakresy (100)
  • Symbole (101)
  • Przekształcanie klas (102)
• Podsumowanie (103)

• Praca z plikami zawierającymi kod źródłowy (105)
  
  • Tworzenie pliku testowego (106)
  • Testowy plik z kodem źródłowym (107)
  • Wykonywanie kodu źródłowego (108)
• Pierwsza aplikacja: analizator tekstu (111)
  
  • Podstawowe funkcje aplikacji (111)
  • Implementacja aplikacji (112)
  • Uzyskanie przykładowego tekstu (112)
  • Ładowanie plików tekstowych i zliczanie wierszy (113)
  • Zliczanie znaków (114)
  • Zliczanie słów (115)
  • Zliczanie zdań i akapitów (117)
  • Obliczenie wartości średnich (119)
  • Kod źródłowy aplikacji (119)
• Dodatkowe funkcje aplikacji (120)
  
  • Procent słów "znaczących" (120)
  • Podsumowanie prezentujące zdania "znaczące" (122)
  • Analiza plików innych niż text.txt (124)
• Program w wersji finalnej (125)
  
• Podsumowanie (127)

• Historia języka Ruby (129)
  
  • Kraj Wschodzącego Słońca (130)
  • Korzenie języka Ruby (131)
  • Inwazja na Zachód (132)
• Ruby on Rails (133)
  
  • Po co utworzono platformę Rails (134)
  • Jak zdobyto Web 2.0 (135)
• Kultura Open Source (135)
  
  • Na czym polega ruch Open Source? (136)
• Gdzie i jak uzyskać pomoc? (137)
  
  • Listy dystrybucyjne (137)
  • Grupy dyskusyjne Usenet (138)
  • Internet Relay Chat (IRC) (138)
  • Dokumentacja (139)
  • Fora (140)
• Dołączanie do społeczności (140)
  
  • Świadczenie pomocy innym (141)
  • Dzielenie się kodem źródłowym (141)
  • Blogi (142)
• Podsumowanie (143)

• Po co używać orientacji obiektowej? (147)
  
• Podstawy orientacji obiektowej (150)
  
  • Zmienne lokalne, globalne, obiektu i klasy (151)
  • Metody klasy a metody obiektu (155)
  • Dziedziczenie (157)
  • Nadpisywanie istniejących metod (159)
  • Refleksja i odkrywanie metod dostępnych w obiektach (161)
  • Enkapsulacja (162)
  • Wielopostaciowość (167)
  • Klasy zagnieżdżone (168)
  • Zasięg stałych (169)
• Moduły, przestrzenie nazw i włączanie kodu (170)
  
  • Przestrzenie nazw (170)
  • Włączanie kodu (173)
• Obiektowa tekstowa gra przygodowa (180)
  
  • Idea gry (180)
  • Klasy początkowe (180)
  • Struktury: proste klasy danych (182)
  • Tworzenie komnat (184)
  • Uruchamianie gry (185)
• Podsumowanie (188)

• Projekty i wykorzystanie kodu z innych plików (191)
  
  • Proste dołączanie pliku (192)
  • Dołączanie kodu z innych katalogów (193)
  • Logika programu a dołączanie kodu (194)
  • Dołączenia zagnieżdżone (195)
• Biblioteki (195)
  
  • Biblioteki standardowe (196)
  • RubyGems (198)
• Podsumowanie (207)

• Tworzenie dokumentacji (209)
  
  • Generowanie dokumentacji przy użyciu RDoc (210)
  • Techniki pracy z RDoc (212)
• Debugowanie i błędy (215)
  
  • Wyjątki i obsługa błędów (215)
  • Metody catch i throw (219)
  • Debuger języka Ruby (220)
• Testowanie (223)
  
  • Filozofia programowania sterowanego testami (224)
  • Testy jednostkowe (226)
  • Inne asercje biblioteki Test::Unit (228)
• Testy wzorcowe i profilowanie (229)
  
  • Proste wzorcowe testy wydajności (230)
  • Profilowanie (232)
• Podsumowanie (233)

• Wejście i wyjście (237)
  
  • Dane wejściowe z klawiatury (238)
  • Wejście i wyjście do pliku (239)
• Proste bazy danych (253)
  
  • Bazy danych w postaci plików tekstowych (253)
  • Przechowywanie obiektów i struktur danych (256)
• Relacyjne bazy danych i język SQL (259)
  
  • Idea relacyjnych baz danych (260)
  • Wielka czwórka: MySQL, PostgreSQL, Oracle i SQLite (261)
  • Instalacja SQLite (262)
  • Krótki kurs podstawowych czynności w bazie danych i języka SQL (262)
  • Korzystanie z SQLite w języku Ruby (267)
  • Łączenie się z innymi systemami zarządzania bazami danych (271)
  • ActiveRecord. Krótki opis (276)
• Podsumowanie (277)

• Dystrybucja prostych programów napisanych w Ruby (281)
  
  • Wiersz ze ścieżką dostępu do interpretera (283)
  • Skojarzone typy plików w systemie Windows (284)
  • "Kompilowanie" kodu języka Ruby (284)
• Wykrywanie środowiska wykonawczego języka Ruby (286)
  
  • Łatwe wykrywanie systemu operacyjnego za pomocą zmiennej RUBY_PLATFORM (287)
  • Zmienne środowiskowe (287)
  • Odczytywanie argumentów wiersza poleceń (289)
• Udostępnianie i dystrybuowanie bibliotek języka Ruby w postaci pakietów gem (290)
  
  • Tworzenie pakietu gem (291)
  • Dystrybucja pakietu gem (295)
  • RubyForge (295)
• Wdrażanie aplikacji Ruby jako usług zdalnych (296)
  
  • Skrypty CGI (296)
  • Serwery HTTP ogólnego przeznaczenia (299)
  • Zdalne wywołania procedur (303)
• Podsumowanie (307)

• Dynamiczne wykonywanie kodu (309)
  
  • Wiązania (310)
  • Inne postacie metody eval (311)
  • Tworzenie własnej wersji attr_accessor (313)
• Wykonywanie innych programów z poziomu języka Ruby (314)
  
  • Odczytywanie wyników działania innych programów (314)
  • Przekazywanie wykonania do innego programu (315)
  • Wykonywanie dwóch programów jednocześnie (315)
  • Komunikacja z innym programem (316)
• Bezpieczne przetwarzanie danych i niebezpiecznych metod (317)
  
  • Niebezpieczne dane i obiekty (317)
  • Poziomy zabezpieczeń (320)
• Praca z systemem Microsoft Windows (321)
  
  • Korzystanie z API systemu Windows (321)
  • Kontrolowanie programów systemu Windows (323)
• Wątki (325)
  
  • Podstawowe czynności z wykorzystaniem wątków Ruby (325)
  • Zaawansowane operacje z wykorzystaniem wątków (326)
• Biblioteka RubyInline (328)
  
  • Po co używać C jako języka wplatanego? (329)
  • Tworzenie prostej metody lub funkcji (329)
  • Testy wzorcowe wydajności kodu C i Ruby (331)
• Obsługa Unicode i UTF-8 (332)
  
• Podsumowanie (335)

• Implementacja bota (337)
  
  • Czym jest bot? (337)
  • Dlaczego bot? (339)
  • Jak implementuje się bota? (339)
• Biblioteka narzędzi do przetwarzania tekstu (340)
  
  • Implementacja biblioteki WordPlay (341)
  • Testowanie biblioteki (346)
  • Kod źródłowy biblioteki WordPlay (349)
• Implementacja głównego modułu bota (351)
  
  • Cykl życia programu i jego elementy (352)
  • Dane dla bota (353)
  • Implementacja klasy Bot oraz mechanizmu ładowania danych (357)
  • Metoda response_to (358)
  • Zabawa z botem (363)
• Kod źródłowy najważniejszych elementów bota (366)
  
  • bot.rb (367)
  • basic_client.rb (369)
• Rozszerzanie bota (369)
  
  • Wykorzystanie plików tekstowych jako źródła danych wejściowych do rozmowy (370)
  • Udostępnienie bota w sieci WWW (370)
  • Rozmowy między dwoma botami (373)
• Podsumowanie (374)

• Pierwsze kroki (377)
  
  • Czym jest platforma Rails i po co się jej używa? (378)
  • Instalacja platformy Rails (379)
  • Bazy danych (381)
• Implementacja pierwszej aplikacji Rails (381)
  
  • Tworzenie pustej aplikacji Rails (381)
  • Inicjalizacja bazy danych (385)
  • Tworzenie modelu i migracji (388)
  • Scaffolding (392)
  • Kontrolery i widoki (395)
  • Routing (404)
  • Relacje między modelami (405)
  • Sesje i filtry (407)
• Pozostałe funkcje (409)
  
  • Makiety (409)
  • Testowanie (412)
  • Moduły rozszerzające (413)
• Dodatkowe zasoby i przykładowe aplikacje (414)
  
  • Witryny i samouczki (415)
  • Przykładowe aplikacje Rails (415)
• Podsumowanie (416)

• HTTP i sieć WWW (419)
  
  • Pobieranie stron WWW (420)
  • Generowanie stron WWW i kodu HTML (427)
  • Przetwarzanie treści WWW (432)
• Obsługa poczty elektronicznej (437)
  
  • Odczytywanie poczty przy użyciu POP3 (437)
  • Wysyłanie wiadomości pocztowych przy użyciu SMTP (439)
  • Wysyłanie wiadomości pocztowych przy użyciu ActionMailer (441)
• Transfer plików przy użyciu protokołu FTP (442)
  
  • Nawiązywanie połączenia i wykonywanie podstawowych czynności FTP (443)
  • Pobieranie plików (444)
  • Ładowanie plików na serwer (445)
• Podsumowanie (447)

• Najważniejsze mechanizmy sieciowe (449)
  
  • TCP i UDP (450)
  • Adresy IP i DNS (450)
• Podstawowe operacje sieciowe (451)
  
  • Sprawdzanie dostępności komputera lub usługi (451)
  • Wykonywanie zapytań DNS (453)
  • Nawiązywanie bezpośredniego połączenia z serwerem TCP (455)
• Serwery i klienty (457)
  
  • Klient i serwer UDP (457)
  • Implementacja prostego serwera TCP (459)
  • Serwery TCP do obsługi więcej niż jednego klienta (460)
  • GServer (462)
  • Serwer czatów oparty na GServer (465)
  • Serwery WWW i HTTP (468)
  • Demony (468)
• Podsumowanie (470)

• abbrev (475)
  
  • Instalacja (475)
  • Przykłady (475)
  • Dodatkowe informacje (476)
• base64 (477)
  
  • Instalacja (477)
  • Przykłady (477)
  • Dodatkowe informacje (479)
• BlueCloth (480)
  
  • Instalacja (480)
  • Przykłady (480)
  • Dodatkowe informacje (481)
• cgi (482)
  
  • Instalacja (482)
  • Przykłady (482)
  • Dodatkowe informacje (487)
• chronic (488)
  
  • Instalacja (488)
  • Przykłady (488)
  • Dodatkowe informacje (489)
• Digest (490)
  
  • Instalacja (490)
  • Przykłady (490)
  • Dodatkowe informacje (492)
• English (493)
  
  • Instalacja (493)
  • Przykłady (493)
  • Dodatkowe informacje (494)
• ERB (495)
  
  • Instalacja (495)
  • Przykłady (495)
  • Dodatkowe informacje (497)
• FasterCSV (498)
  
  • Instalacja (498)
  • Przykłady (498)
  • Dodatkowe informacje (502)
• iconv (503)
  
  • Instalacja (503)
  • Przykłady (503)
  • Dodatkowe informacje (504)
• logger (505)
  
  • Instalacja (505)
  • Przykłady (505)
  • Dodatkowe informacje (507)
• pp (508)
  
  • Instalacja (508)
  • Przykłady (508)
  • Dodatkowe informacje (509)
• RedCloth (510)
  
  • Instalacja (510)
  • Przykłady (510)
  • Dodatkowe informacje (511)
• StringScanner (512)
  
  • Instalacja (512)
  • Przykłady (512)
  • Dodatkowe informacje (514)
• tempfile (515)
  
  • Instalacja (515)
  • Przykłady (515)
  • Dodatkowe informacje (517)
• uri (518)
  
  • Instalacja (518)
  • Przykłady (518)
  • Dodatkowe informacje (521)
• zlib (522)
  
  • Instalacja (522)
  • Przykłady (522)
  • Dodatkowe informacje (523)

• Podstawy (528)
  
  • Definicje i pojęcia (528)
  • Interpreter języka Ruby i wykonywanie kodu Ruby (529)
  • Interactive Ruby (530)
• Wyrażenia, logika i przepływ sterowania (531)
  
  • Podstawowe wyrażenia (531)
  • Niezgodności klas (532)
  • Wyrażenia porównawcze (533)
  • Przepływ sterowania (534)
• Orientacja obiektowa (538)
  
  • Obiekty (538)
  • Klasy i metody (539)
  • Refleksja (541)
  • Ponowne otwieranie klas (542)
  • Widoczność metod (543)
• Dane (544)
  
  • Ciągi znaków (544)
  • Wyrażenia regularne (545)
  • Liczby (546)
  • Tablice (548)
  • Tablice asocjacyjne (549)
  • Struktury złożone (549)
• Wejście-wyjście (550)
  
  • Pliki (550)
  • Bazy danych (551)
  • Sieć WWW (551)
• Biblioteki (552)
  
  • Organizacja plików (552)
  • Tworzenie pakietów (553)

• Przydatne klasy i metody (555)
  
  • Array (555)
  • Bignum i Fixnum (557)
  • Enumerable (558)
  • Float (559)
  • Hash (559)
  • Integer (560)
  • Numeric (560)
  • Object (561)
  • String (562)
• Składnia wyrażeń regularnych (564)
  
  • Opcje wyrażeń regularnych (564)
  • Specjalne znaki i formacje (565)
  • Sufiksy znaków i podwyrażeń (565)
• Klasy wyjątków (566)
  
• Zmienne specjalne (568)
  
• Licencja języka Ruby (570)

• Informacje ogólne (573)
  
  • Ruby (573)
  • Ruby on Rails (574)
• Blogi (575)
  
  • Blogi społecznościowe i spisy blogów (575)
  • Blogi prywatne (576)
• Fora i grupy dyskusyjne (577)
  
• Listy dystrybucyjne (577)
  
• Czaty w czasie rzeczywistym (578)
  
• Samouczki i przewodniki (579)
  
  • Instalacja (579)
  • Ruby i sposoby korzystania z niego (580)
  • Ruby on Rails (581)
  • Inne (582)