Podstawy subversion (SVN)

No tak, pewnie (podobnie jak ja) słyszałeś 2,500 razy aby tego używać w swoich projektach ale może wciąż zastanawiasz się po co, i jak. Sp19róbujemy coś z tym zrobić.

Co robi SVN ?
W dużym skrócie SVN przetrzymuje pliki, które każesz mu przetrzymywać jednak w taki sposób, że jest w stanie otworzyć dowolny z tych plików w dowolnej z jego kiedykolwiek istniejących wersji. Jeżeli edytowałeś plik 100 razy i wprowadziłeś w nim 100 zmian. To SVN pozwoli Ci wrócić do dowolnej ze zmian (przywrócić plik w postaci z przed zmiany 39 jak i z postaci jaką przybrał po zmianie 76).

Po co SVN ?
Podam kilka tylko przypadków w których SVN okazuje się użyteczny:

1. Masz system operacyjny, w którym jest kilku administratorów. Trzymanie w SVN plików konfiguracyjnych systemu pozwala na natychmiastowe wrócenie do stanu poprzedniego (działania) w momencie w którym po jakiejś zmianie coś przestaje działać - bez zastanawiania się i szukania pomyłki.
2. Kilku programistów pracuje nad tym samym projektem i istnieje groźba, że będą pracowali nad tym samym fragmentem kodu w jednym czasie.
3. Szlak trafił nam projekt, ktoś narozrabiał i wywalił pliki, które właśnie są Ci potrzebne. Przywracasz je jednym poleceniem.
4. Nawet jeżeli coś było tylko epizodem w twoim życiu i dawno usunąłeś te dwa skrypty rubego ze swojego dysku, a używałeś w trakcie svn-a to możesz (nawet po 2 latach) do nich wrócić....
   

Skrócony opis obsługi SVN:
Oprę się na świetnym tutorialu dostępnym pod adresem: http://artis.imag.fr/~Xavier.Decoret/resources/svn/index.html
Przedstawię tylko i wyłącznie podstawy jednak w pewnym konkretnym ujęciu, które może okazać się dobrym uzupełnieniem powyższego artykułu:

1. Tworzymy miejsce, w którym będziemy przetrzymywać nasz projekt:
   mkdir /mnt/saveplace/dziubdziub/svn
   svnadmin create --fs-type fsfs /mnt/saveplace/dziubdziub/svn
   Tak przygotowany katalog będzie bazą dla polecenie svn, którym zaczniemy się posługiwać.
   
2. Importujemy nasz projekt do svn (robimy to tylko raz ! na początku projektu):
   svn import /home/dziubdziub/poszukiwania file:///mnt/saveplace/dziubdziub/svn/poszukiwania -m "Initial import"
   Co właśnie zrobiliśmy ? Otóż kazaliśmy svn-owi (w jemu tylko znany sposób) zaimportować cały projekt z plikami i opisać tą zmianę "Initial import"
3. Po imporcie musimy wykonać checkout (tylko raz tylko na początku zaraz po zaimportowaniu), który pobierze nasze pliki z svn-a. Możemy wykonać go do innego katalogu. Możemy wykasować istniejący projekt i w jego miejsce pobrać spowrotem te same pliki z svn-a:
   cd /home/dziubdziub
   rm -fr poszukiwania
   svn checkout file:///mnt/saveplace/dziubdziub/svn/poszukiwania
   
4. Kiedy wykonaliśmy checkout możemy zacząć używać svn-a. Od tej pory w katalogach z projektem istnieją katalogi .svn, które przetrzymują informacje pozwalające nam nie podawać ścieżki file://... ale działać bez niej (dzięki tym katalog svn sam wie gdzie są trzymane repozytoria) Powiedzmy, że nad projektem na tym repozytorium pracuje kilku programistów. Aby mieć najświeższą wersję ZAWSZE przed rozpoczęciem pracy wykonujemy:
   cd /home/dziubdziub/poszukiwania
   svn update
   Dzięki czemu pobierzemy najnowszą wersje plików.
   
5. Po wprowadzonej przez siebie zmianach schodzimy do najniższego katalogu i patrzymy co się zmieniło:
   svn status
   ? - plik został dodany lub usunięty i nie wiadomo co z nim zrobić
   ! - plik został usunięty
   M - plik został zmodyfikowany
   
6. Podejmujemy jedną z kilku akcji względem plików oznaczonych ?:
   svn add sciezka/do/pliku - dodajemy (?)
   svn rm sciezka/do/pliku - usuwamy (!)
   
7. Po podjęciu akcji (nie ma żadnych plików oznaczonych ?, ! ale same oznaczone A(dd), D(elete), M(odify) każemy wprowadzić zmiany do repozytorium SVN:
   svn commit -m "Description of changes"
   
8. Za każdym razem po wprowadzeniu zmian musimy ponownie (jakby od początku) wykonać svn update ponieważ nasze zmiany zostały nałożone na zmiany innego programisty w svn i trzba pobrać skompilowaną wersję tych wszystkich wspólnych zmian (które łączy svn):
   svn update
   

Luźne rady:

1. Komituj każdą najdrobniejszą zmianę. Im więcej i częściej będziesz komitować tym szczegółowiej będziesz mógł określić, która ze zmian Cię intereuje w kodzie (i chcesz ją zatrzymać) a która nie.
2. Nie warto dodawać do repozytorium plików czy katalogów tymczasowych czy np... plików pochodzących z mechanizmu cachowanie czy logów. Dlatego warto oznaczyć niektóre katalogi aby były ignorowane (zmiany w nich zachodzące dokładnie) przez svn. Powiedzmy, że mamy katalog tmp w którym jest katalog cache i logs, których zawartości nie chcemy brać pod uwagę podczas naszego commitowania. Każdy z katalogów ma swoją listę ignorowanych plików. Robimy to mniej więcej tak:
   cd /home/dziubdziub/poszukiwania/tmp
   svn propedit svn:ignore logs
   Wpisujemy: *
   Od teraz w katalogu logs ustawiony jest parametr svn:ignore na * (wszystkie pliki). Analogicznie postępujemy z cache:
   cd /home/dziubdziub/poszukiwania/tmp
   svn propedit svn:ignore cache
   Wpisujemy: *
3. Aby przywrócić jakiś plik wpisz:
   svn revert sciezka/do/pliku
   
4. Program svn pozwala nam działać na wirtualnym systemie plików znajdującym się w: /mnt/saveplace/dziubdziub/svn na zasadzie zwykłych poleceń systemowych poprzedzonych svn:
   svn ls file:///mnt/saveplace/dziubdziub/svn/poszukiwania
   svn rm file://...
   svn mkdir file://...
   svn tree file://...
   Pomimo tego, że polecenia:
   ls file:///mnt/saveplace/dziubdziub/svn/poszukiwania
   rm file://...
   mkdir file://...
   tree file://...
   A w katalogu /mnt/saveplace/dziubdziub/svn wcale nie znajdzmyjawnie pokazanych naszych folderów, ale tylko i wyłącznie wewnętrzną strukturę organizacji danych stworzoną przez svnadmin.
   

OJP 1 zajęcia :)

Dziś na zajęciach z OJP usłyszałem pierwszy raz jak wygląda obiektowe programowanie w ujęciu "ewolucji". Powiedzmy, że robimy bazę danych samochodów:



int : rocznik

int : przebieg

string : rejestracja

string : kolor



Operujemy na 4 tablicach - funkcja, która miałaby operować na samochodzie musiałby przyjmować 4 parametry (porażka)... lub działać na zmiennych (tablicach) globalnych. Sortowanie takich samochodów np. według rocznika czy przebiegu sprawia, że drobny błąd w algorytmie (operującym na 4 tablicach) rozsynchronizuje bazę.



Kolejnym pomysłem jest zamknąć te dane w strukturze samochód:



struct samochod {

int : rocznik
int : przebieg
string : rejestracja
string : kolor

}



Dzięki temu funkcja (np. funkcja info() wyświetlająca informację o samochodzie) może przyjmować już tylko jeden parametr (samochód)... Jednak teraz programista może celowo (lub przypadkowo) zmniejszyć przebieg lub zmienić rocznik - czego byśmy nie chcieli. Nasz obiekt nie jest bezpieczny, nie jest niezmienniczy. Nie możemy zagwarantować, że przebieg się nie zmieniszy, że rocznik się nie zmieni.



Idąc dalej możemy zamknąć wszystko w klasie a dane umieścić w sekcji private.



class samochod {



// Interfejs: co sie składa na samochód

private:
int : rocznik

int : przebieg

string : rejestracja

string : kolor

string : numer_silnika

string : marka



public:

// Implementacja: jak się zachowuje samochód

zmien_przebieg() {

++przebieg;

}
}



Dzięki temu programista nie może zmniejszyć przebiegu:



samochod * mazda_jasia = new samochod();

mazda_jasia->przebieg = 200 km;



Dzięki temu jesteśmy pewnie, że przebieg nigdy się nie zwiększy. Minusem tego jest jednak, że nie możemy odczytać przebiegu:



cout <<>przebieg;



No i mamy problem. Musimy więc dopisać nową metodę.



int function Samochod::pobierz_przebieg() {

return this.przebieg;

}



Dzięki temu mamy pełna kontrolę nad przebiegiem. Jesteśmy pewni, że nie zmniejszy się jednak możemy sprawdzić jego wartość i monotonicznie go zwiększać. Jednak jaki rocznik będzie miał samochód, który jest nowo utworzony ? No właśnie. Często zero, jednak nie można na tym polegać... Musimy więc zainicjować wartości na nowo - robimy to w konstruktorze.



Samochod::Samochod() {

this.rocznik = 1970;

this.przebieg = 0;

}



Jednak taki samochód nie ma ani marki ani koloru. Możemy więc zrobić inny konstruktor.



Samochod::Samochod(string _rejestracja, string _silnik, unsigned int _rocznik ...) {

rejestracja = _rejestracja;

silnik = _silnik;

rocznik = _rocznik;

}



Jednak kiepskim pomysłem jest wypisywanie w liście wszystkich parametrów. W powyższym przypadku tworzą się kopie obiektów, które są przekazywane przez do metody. Możemy jednak nie przekazywać parametrów i nie przypisywać ich do skałdowych klasy w ciele konstruktora. Do tego słuzy lista inicjalizacyjna:



Samochod::Samochod(string _rejestracja, string _silnik ...):rejestracja(_rejestracja), silnik(_silnik), kolor("czerwony") {

[...] // tutaj ciało metody

}



Mamy teraz przeciążony konstruktor (istnieją i moga istnieć różne funkcje o tych samych nazwach a o różnych parametrach). Możemy np. zrobić dodatkową metodę zwiększ przebieg:



Samochod::zwieksz_przebieg(int ile) {

if (ile > 0) {

przebieg += ile;

}

}



W C++ mamy możliwość dawać parametrow wartości domyslne, co pozwala uiżytkownikom daje mozliwośc na opuszczanie parametrów. Na z 2 metod zwieksz przebieg możemy zrobić 1:



class {

[...]



zwieksz_przebieg(int ile = 1);

-







-

Samochod::zwieksz_przebieg(int ile) {

}



mazda_jasia->zwieksz_przebieg(); // += 1

mazda_jasia->zwieksz_przebieg(12); // += 12



Wartości domyślne (zmienne z wartościami domyślnymi) dajemy na końcu.



Dalej mówiac o konstruktorze. Jeżeli tworzymy knstruktor dla klasy to musimy zadbać, żeby wszystko było w nim zainicjowane.



Dziedziczenie:

------------------------------------------------



Stosujemy kiedy chcemy stworzyć specjalizację klasy, lub dodać jakieś cechy lub zachowania, których nie miała klasa oryginalna.



-------------

samochod < [ samochod_sportowy ] (bool spoiler, unsigned int data_tuningu)

-------------

^

i a kind of

^

--------------

ciezarowka

--------------



Kiedy zaczniemy dodawac do klas pochodnych coraz wiecej metod czy skladowych pokaze, ze nie warto tworzyc jednej wielkiej klasy samochod z ogromna ilosccia skladowych, poniewaz niektore skladowe (spoilery) dotycza tylko i wylacznie samochodwo sportowych, a w samochodach musialby by zaincjalizowane na jakies dizwne bezsensowen wartosci. Jak wyglada dziedziczenie:



class Ciezarowka public Samochod {



private:

// ciezarowka stala sie samochodem. Dodajemy tylko to co chcemy dodać:

int ladownosc; // Tym się różni od samochodu.

}



Jakie można popełnić błędy ? 1) Otóż mazda nie DZIEDZICZY po samochodzie. Jest samochodem ! a nie klasą... Powinna być obiektem klasy samochód ! a nie samochodem !



2) Kompozycja (is a part of) -> jest częścią. Na przykład silnik jest częścią samochodu, ale nie dziedziczy po samochodzie ! Jest natomiast częścią samochodu ! (diamencik).



3)



elipsa <- punkt : połżenie_środka, float : szerokość, float : wysokość, narysuj()...



Koło nie może dziedziczyć po elpisie ! Koło => (szerokość = wysokość). Wszystko jest ok do momentu, kiedy my nie skomplikujemy elipsy.... np po dodaniu Elipsa::Rozciagnij() { szerokosc *= 2) okazuje się, że koło nie jest dobryn przykładem na dziedziczenie z elipsy... bo koła nie wolno dodawać.



Zasada substytucji Miskowa.



-----------------

Zasłanianie !

-----------------



Samochód: function f(int par), f(string par), f(float par);



class SamochodSportowy public Samochod {



funtion f(string par) {

// Ta metoda zaslania WSZYSTKIE funkcje f z Samochod

}



}



Przeciązanie: w jednej klasie te same nazwy różne parametry

Zasłanianie: w klasie pochodnej metoda o tej samej nazwie.



Dwa sposoby na wybrnięcie z problemu:



1) using Samochod::f; <- pierwszy sposób

2) Wywołać Samochod::f() <- w metodzie klasy.



Projekty ! (wymyślić obiekt do hierarchi dziedziczenia)

Psi i Pidgin - solucje

Wszystko zaczęło się gdy zażyczyłem sobie SSLa do Google Talk na Psi... Znalazłem jakieś QCA w systemie ale SSLa nie było. Dopiero w README doczytałem, że do QCA potrzebne jest QCA-TLS aby Psi łapał szyfrowanie. Jednak w systemie miałem OpenSSLa 0.9.8e ... co zrobiłem ?

[Psi]

Wywaliłem OpenSSL 0.9.8e - który miałem zainstalowany.
Skompilowałem czyste QCA [http://delta.affinix.com/download/qca/qca-1.0.tar.bz2]
Skompilowałem OpenSSL 0.9.6m [http://www.openssl.org/source/openssl-0.9.6m.tar.gz], który domyślnie zagnieździł się w /usr/local/ssl
Skompilowałem plugin QCA niezbędny do działania SSLa w Psi [http://delta.affinix.com/download/qca/qca-tls-1.0.tar.bz2]:

./configure --with-openssl-inc=/usr/local/ssl/include --with-openssl-lib=/usr/local/ssl/lib

Uruchomiłem wcześniej zainstalowane Psi. Psi obsługuje już SSLa.

[Pidgin]
Bardzo spodobał mi się Pidgin [http://pidgin.im/pidgin/home/]. Jednak na wstępie miałem z nim już problemy. Otóż po zaimportowaniu listy kontaktów z serwera Gadu-Gadu podczas wyszukiwania przez wpisywanie gdb wyrzucał jakieś błąd sprawdzającej chyba długość stringu, a po kolejnym uruchomieniu wyskakiwał błąd, że nie można czytać blist.xml, że został skopiowany do blist.xml~ i, że jest źle.

Zajrzałem więc do ~/.purple/blist.xml~ - okazało się, że jest tam moja stara lista kontaktów, tylko są w niej jakieś dziwne krzaki. Doszedłem do wniosku, że to coś z kodowanie nie tak :/ Wszedłem więc do mojego kadu i wyeksportowałem listę do pliku kontakty.txt. Jednak po zaimportowaniu Jej do pidgina nadal było źle. Metodą prób i błędów znalazłem solucję. Otworzyłem plik z eksportem kotantków z kadu (kontakty.txt) w leafpad i zapisałem go ponownie ustawiając w Zapisz jako ... kodowanie na CP1250 CR+LF jako cp1250_kontakty.txt. Po zaimportowaniu kontaktów z tak przygotowanego pliku do Pidgina krzaczki zniknęły. Jednak to nie koniec :/ Otóż pidgin błędnie koduje znaczki (u mnie w nazawach grup). Otwieramy plik (kodowany jako utf-8) ~/.purple/blist.xml, ręcznie szukamy nieprawidłowo wpisanych znaków i je poprawiamy. U mnie osobiście występowały w nazwach grup w znaczniku name="". Po wprowadzeniu poprawek zapisujemy plik na razie pod jakąś inną nazwą (u mnie n_blist.xml) kodowany jako utf-8 (wszystko można wykonać na przykład w leafpad) Zamykamy pidgina. Pidgin błędnie zapisał nazwy do pliku blist.xml jednak nasz plik n_blist.xml jest poprawiony :) podmieniamy więc plik blist.xml na nasz własny, odpalamy pidgina i cieszymy się :)

Ładny terminal

Najlepiej działającym u mnie terminalem jest urxvt. Udało mi siew końcu ustawić dla niego przezroczystość. Oto mój plik .Xdefaults:

URxvt.background: black
URxvt.foreground: white
URxvt.font: -misc-fixed-medium-r-normal--18-120-100-100-c-90-iso8859-2
URxvt.scrollBar: false
URxvt.tintColor: white
URxvt.shading: 20
URxvt.inheritPixmap: true
URxvt.saveLines: 777
URxvt.geometry: 110x40
#URxvt.loginShell: true

System kontroli wersji podstawy

Zostałem ostatnio zmuszony do używania systemu kontroli wersji. No i dobrze. Na reszcie się czegoś nowego nauczę. Bardzo dobry tutorial, poleconym mi przez Łukasza, opisuje wszystko co trzeba wiedzieć aby z niego korzystać.

Do czego używać SVNa i dlaczego używać SVNa.

1) Każda zmiana jest logowana wraz z nazwą użytkownika. Wiesz więc kto co i kiedy zmienił w kodzie.
2) Gdy okazuje się, że program nie działa możesz jednym poleceniem wrócić do poprzedniego stanu - stanu w którym działał.
3) W razie utraty plików odzyskasz je z SVNa.

To tylko kilka cech, które zauważyłem. Na pewno bardziej zaawansowani użytkownicy podali by znacznie więcej argumentów. Jednak te wystarczają aby spróbować nauczyć się choć podstaw tego narzędzia. SVN trzyma informacje o projektach w swojej bazie. Musimy wybrać sobie katalog, gdzie svn będzie trzymał swoje informacje. Powiedzmy, że dla użytkownika dziubdziub będzie to katalog svn w jego katalogu domowy. Jako użytkownik dziubdziub wydajemy polecenie:

svnadmin create --fs-type fsfs /home/dziubdziub/svn

Polecenie to stworzy "bazę danych" dla SVN a. Teraz możemy zacząć z niego korzystać. Powiedzmy, że w katalogu public_html tworzymy stronę internetowa dziubdziub. Mamy więc katalog /home/dzibdziub/public_html/dziubdziub w którym są pliki naszej strony internetowej. Jeżeli chcemy je włączyć do naszego systemu kontroli wydajemy polecenie:

svn import /home/dziubdziub/public_html/dziubdziub file:///home/dziubdziub/svn/dziubdziub -m 'Pierwszy import. (działa)'

Co właśnie zrobiliśmy. Już omawiam:

svn - uruchomiliśmy program svn
import - z opcją importowania istniejącego projektu do Jego bazy danych (drugie polecenie to zawsze import)
/home/dziubdziub/public_html/dziubdziub - projektu znajdującego się w tym katalogu
file:///home/dziubdziub/svn/dziubdziub - i zaimportować go do katalogu SVN file:///home/dziubdziub/svn/ jako dziubdziub - SVN założy sobie swój własny katalog dziubdziub i będzie w nim trzymał pliki naszego projektu.
-m "Pierwszy import. (działa)" - Każdy "import" musimy jakoś opisać. W opis wpisujemy zmiany, których dokonaliśmy, oraz możemy zaznaczyć czy coś działa, co zaczęło działać, a może coś było do dokończenia...

Kilka słów komentarza. SVN tworzy swój własny "system plików"... Po zajrzeniu do /home/dziubdziub/svn zobaczymy tylko kilka nic nie mówiących nam plików i katalogów. Aby oglądać ten system plików wydajcie polecenie:

svn ls file:///home/dziubdziub/svn/
svn ls file:///home/dziubdziub/svn/dziubdziub

Zobaczymy nasze pliki :) Istnieją też komendy svn rm, svn mkdir i kilka innych analogicznych do poleceń dostępnych w powłoce Linuksa. Jeżeli wywołamy:

svn log file:///home/dziubdziub/svn/
svn info file:///home/dziubdziub/svn/dziubdziub

Dowiemy się jakie zmiany zaszły w naszych plikach. Powinniśmy teraz wykonać checkout-a. W tym celu przejdźmy do katalogu /home/dziubdziub/public_html (katalog niżej niż projekt), zmieńmy nazwę projektowi (lub usuńmy go, ja jednak wolę zmienić nazwę i nie usuwac plików na wypadek, gdyby SVN nawalił) mv dziubdziub dziubdziub_bak. Teraz katalog dziubdziub nie istnieje. Możemy teraz wykonać checkout svn checkout file:///home/dziubdziub/svn/dziubdziub. Co się stało ? SVN przeniósł zapisane przez siebie pliki do katalogu. Została sprawdzona poprawność naszego importu i coś jeszcze :)... Otóż po wykonaniu w katalogu projektu (w każdym z katalogów) okazuje się, że znajduje się katalog .svn. Dzięki niemu nie będziemy musili podawać ścieżki przy wykonywaniu poleceń svn log, svn info. Po wykonaniu checkout a możemy edytować swoje pliki i zmieniać je, tak jak wcześniej. Kiedy dokonamy zmian i chcemy odnotować je w naszym SVN możemy najpierw sprawdzić co nasz SVN odnotował. Sprawdzamy to wchodząc do katalogu z projektem i wpisujemy komendę svn status. Odpowiednie zmiany, usunięcia, dodania będą oznaczone odpowiednimi literkami. Powiedzmy, że utworzyliśmy plik opis.txt. Wtedy svn status wyrzuci nam:

? opis.txt

Musi więc dodać go do naszego SVN svn add opis.txt:

A opis.txt

I odnotować zmiany w naszym repozytorium. svn commit -m "Plik z opisem do programu." okraszając go odpowiednim komentarzem. Ale halo halo ! Ci, którzy zamiast czytać dalej spróbują wywołać svn log stwierdzą... Nić się nie zmieniło... A no właśnie. Musimy ponownie wejść katalog niżej cd .. skasować katalog rm -fr dziubdziub i wykonać checkout. svn checkout file:///home/dziubdziub/svn/dziubdziub Pliki zostaną przywrócone a svn log pokaże kolejną zmianę. Zwrócę jeszcze tylko uwagę na pewien drobiazg. Checkout (i commit) podają na dole numerek... checkout zawsze przywróci nam ostatnio opisaną wersję programu. A co jeżeli chcielibyśmy na przykład pierwsza ? Nic prostrzego. Powiedzmy, że chcielibyśmy wersję numer 1 (musi taka istnieć, jeżeli taka nie istenieje program zwróci błąd). Ponownie kasujemy katalog dziubdziub i wykonujemy polecenie svn checkout -r 1 file:///home/dziubdziub/svn/dziubdziub i analogicznie w zależności, do jakiego stanu chcecie przywrócić swój projekt.

Checkouta robimy tylko za pierwszym razem kolejne zmiany po wykonaniu commit (wcześniej add, del itd...) wykonaujemy komendą svn up

SVNa można używać także do utrzymywania porządków w plikach systemowych - szczególnie jeżeli jest wielu adminów, którzy wprowadzają wiele zmian.

Gdzie jest ...

Ciemno...
Czy jesteś przy mnie ?

Cisza...

Czy jesteś przy mnie ?

Kapanie...

Czy jesteś przy mnie ?

Ptak zatrzepotał skrzydłami...

Czy jesteś przy mnie ?

"Nie ma mnie ..."

Odpowiedział delikatnie słodki, kryształowy głos...

Klucz

Zamknąłem swoje serce na złotą kłódkę z żelaza
I obciąłem sobie obie dłonie.

Wyzierając z zardzewiałego otworu
Złoty klucz sterczy i lśni w słońcu
Niczym strzała w piersi wojownika
Groźnie łypiąca swym krwawym pióropuszem
Na pole bitwy gdzie polegli ... zwycięzcy.

Klucz czeka ...

Aż weźmiesz go w swoje dłonie
Ożywisz dotykiem śnieżnobiałego cedru i płatków róż
Nie ważne kim będziesz, choć ma swoje marzenia.
Czeka tylko na czułości uśmiechu, kroplę miłości i ...
... zaufanie

I znajdziesz tam przestraszone szczenię
skulone w kącie,
z oklapłymi uszami,
walącym ze strachu sercem i
parą wielkich zaszklonych oczu, patrzących błagalnie wprost w Twoje serce

Przytul je - ono tylko tyle potrzebuje.