.gitlab-ci.yml

@@ -13,13 +13,13 @@ home:
     - cp .magic_ssh_config ~/.ssh/config
   script:
     # AFS magic incoming
-    - ssh rlacko@centaur.sch.bme.hu cp /afs/sch.bme.hu/home/rlacko/.system/rlacko.keytab /tmp/rlacko.keytab
-    - ssh rlacko@centaur.sch.bme.hu kinit -k -t /tmp/rlacko.keytab rlacko
-    - ssh rlacko@centaur.sch.bme.hu rm /tmp/rlacko.keytab
-    - ssh rlacko@centaur.sch.bme.hu aklog sch.bme.hu -k SCH.BME.HU
-    - ssh rlacko@centaur.sch.bme.hu mkdir -p /home/rlacko/public_html/git
+    - ssh blintmester@centaur.sch.bme.hu cp /afs/sch.bme.hu/home/blintmester/.system/blintmester.keytab /tmp/blintmester.keytab
+    - ssh blintmester@centaur.sch.bme.hu kinit -k -t /tmp/blintmester.keytab blintmester
+    - ssh blintmester@centaur.sch.bme.hu rm /tmp/blintmester.keytab
+    - ssh blintmester@centaur.sch.bme.hu aklog sch.bme.hu -k SCH.BME.HU
+    - ssh blintmester@centaur.sch.bme.hu mkdir -p /home/blintmester/public_html/git
     # actual work
-    - scp -r $PWD/* rlacko@centaur.sch.bme.hu:/home/rlacko/public_html/git/
+    - scp -r $PWD/* blintmester@centaur.sch.bme.hu:/home/blintmester/public_html/git/
   only:
     refs:
       - master

guide/ scripts/elso.md

+Sziasztok, `<insert name here>` vagyok!
+
+Üdvözlök mindenkit. A videóban a gitről szeretnék mesélni nektek, és a végére remélem sikerül olyan szintű tudást átadnom, hogy a jövőben ne *nagyon* okozzon problémát a verziókezelés.  
+Olyan kérdésekre fogok választ adni, mint *"Miért kell git-et használnom?"*, *"Miért ilyen bonyolult ez az egész?"* és *"Mégis mi a francot nyerek ezzel?"*  
+Amire szükséged lesz: egy konzol, működő git-el (erre majd később visszatérek).
+
+
+
+A parancsokat nem kötelező nektek is kiadni, de egész hasznos lesz, ha már csináltatok ilyet a gyakorlatra.
+
+
+## Mi is az a verziókezelés?
+
+(ide beszúrhatod a saját szövegedet, ha szeretnéd)
+
+Biztos mindannyiótoknak van egy olyan élménye, hogy írt egy dokumentumot. Ezt elmentette, majd egy hét múlva újra írt bele, és szerette volna, hogy a korábbi munkája megmaradjon, vagy csak rögzíteni a különböző állapotokat.
+
+Ezekből szoktak megszületni az itt látható mappák, fájlok.
+
+(ide majd be fogok vágni egy képet, amin látszik a első.docx, első_v2.docx, etc...)
+
+Természetesen ez lehetne egy használható megoldás, de mi van, ha szeretnénk valakivel ezt megosztani? Mi van ha a módosítás dátuma megváltozik közben? Hogyan biztosítjuk, hogy nem sérülnek a fájlok, és nem veszik el egy változata a munkánknak, amire lehet egy-két hét/hónap múlva mégiscsak vissza kell térjünk?
+
+Erre adnak megoldást a különböző verziókezelő rendszerek. Ezeknek többek között dolguk, hogy számon tartsák a fájljainkat, ahogyan mi ezt kézzel megtettük.
+
+### Helyi
+
+Erre a fenti példa a legjobb példa.  
+Vannak különböző verziói a fájlunknak és ezeket valamilyen
+adatbázisban rögzítjük.
+
+(ide kép jön majd)
+
+### Központosított
+
+Ez már egy fokkal okosabb.
+A különböző verziókat a központi szerverre rakjuk fel és
+onnan szedjük le.  
+Például van egy Fájlszerverünk amit minden gépről elérnek
+az emberek és oda dolgoznak közösen...  
+Érezhető probléma, hogy így ha meghal a központi szerver,
+akkor mindent elvesztünk (eskü nem volt még ilyen 😅).  
+Továbbá probléma lehet, hogy egymás munkáját felülírjük,
+szerencsére egy jó rendszernél erről értesítést kapunk,
+hozzá és nem felülírjuk a módosításaink.
+
+(ide kép jön majd)
+
+### Megosztott
+
+Na és itt lépünk be a ma is használt Git világába.
+Ennél a megoldásnál már az a trükk, hogy mindenkinek megvan
+a teljes projekt az összes verziójával. Felmerül, hogy na
+de akkor honnan szedjük le a legújabb verziót?
+Különböző megoldások léteznek, például a fejlesztők a
+módosításokat azonnal megosztják egymással
+(pl.: p2p Torrenthez hasonló módon) vagy
+kijelölnek egy központi szervert amivel mindenki
+szinkronban van.
+Ilyen központi szerver lehet például a [Github](https://github.com/) vagy a [Gitlab](https://gitlab.com/).  
+Csak megjegyzem, akár a módosításokat emailben is el lehet
+küldeni és a szoftver automatikusan megcsinálja a többit a mi részünkön.
+
+
+## Git története
+
+Még mielőtt belemerülnék a git telepítésébe, használatába,
+szeretnék némi sztorizást is megejteni.
+
+Annó a Linux kernel fejlesztése során okozott nagy fejtörést
+az egész verziókezelés megoldása.
+1991-től 2002-ig, tehát 11 éven át patchekben
+(pl.: e-mailben elküldött szöveg a módosításokkal)
+és tömörített fájlokban küldözgették a verziókat a fejlesztők.
+Aztán 2002-től egy zárt licenszű verzió kezelőre, a
+[BitKeeper](http://www.bitkeeper.org/)-re váltottak.
+
+Ezt a Linux fejlesztői ingyen használhatták egészen 2005-ig,
+mikorra annyira elromlott a kapcsolat a fejlesztők és a cég
+között, hogy elvették tőlük a licenszt.
+Az i-re a pontott az tette fel, mikor az egyik
+kernel fejlesztő
+[reverse engineer-elte](https://lwn.net/Articles/132938/)
+a BitKeeper-t.  
+Ekkoriban
+[Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds)
+úgy döntött, hogy egy új megoldást kell találnia, mely
+
+- gyors
+- egyszerű
+- támogatja a többszálú fejlesztést
+- teljesen elosztott
+- nagy projekteket is képes kezelni (pl.: Linux kernel)
+
+Így hát megírta a [Git](https://en.wikipedia.org/wiki/Git)-et, mely a mai napig a legelterjedtebb, leggyorsabb és
+legkényelmesebb verzió kezelő rendszer.

guide/ scripts/masodik.md

+Sziasztok, Blint vagyok!
+
+Másfél éve kszk-zom, leginkább a sysadminban találhattok meg, nemrég lettem megválasztva a kubernetesünk rendszergazdájának. A git-et már jó pár éve használom aktívan, el se tudom képzelni, hogy ne használjam egy projekthez.
+
+Ebben a videóban szeretném nektek a git gyakorlati alkalmazását megmutatni, abba bevezetni titeket.
+
+Kezdetben szeretnélek megkérni, hogy telepítsétek fel a git-et a gépetekre a segédletben leírtak szerint, vagy használjátok a linuxos előadáshoz kapott vm-eteket.  
+
+Én alapból zsh-t használok a gépemen, így lehet, pár dolog nem ugyanúgy fog kinézni, mint nálatok (ha bash-t használtok), de minden ugyanúgy működik (ez egy POSIX shell), csak kicsit barátságosabban néz ki 😉.
+
+## Konfiguráció
+
+Állítsuk be magunknak a git-et, hogy kényelmesen tudjuk használni.  
+
+Először is a saját adatainkat állítsuk be, ezt a:
+
+```
+git config --global user.name "Bálint Réthelyi"
+git config --global user.email rethelyibalint@gmail.com
+```
+
+begépelésével tehetjük meg.
+
+Ezután állítsuk be, hogy a git milyen szövegszerkesztőt nyisson meg alapértelmezetten, ezt főként `commit`-oknál és `merge`-eknél fogjuk használni.
+
+A szükséges parancs pedig:
+
+```
+git config --global core.editor vim
+```
+
+Én szeretek `vim`-et használni, de ti nyugodtan beállíthattok magatoknak `nano`-t, vagy akár a VS Code-ot is, sokszor elég kényelmes tud lenni.
+
+Esetleg windows-on a notepad++-t is beállíthatjátok, ehhez a parancsot a segédleteben láthatjátok.
+
+### Jelenlegi konfig
+
+Nah, akkor nézzük meg, eddig mit alkottunk, hogy néz ki az összes git-es beállításunk:
+
+Ezt a:
+
+```
+git config --list
+```
+parancs kiadásával nézhetjük meg.
+
+## Alapok
+
+Ha elakadtok git használat közben, akkor rengeteg segítség létezik, szerencsére a git-nek van egy nagyon jó help parancsa, valamint a man page-t is lehet nézegetni.
+
+### Git repo
+
+A git repository, vagy repo egy olyan mappa, mely gites verziókövetve van, azaz bárhol, ahol találunk egy .git mappát, az valójában egy git repo.
+
+Kezdjünk is bele, készítsünk egy saját repot!
+
+Ehhez készítsünk egy tetszőleges mappát, ez lesz a projektünk mappája, és lépjünk is bele.
+
+```
+mkdir projektem
+cd projektem
+```
+
+Persze megnézhetjük, mi a helyzet a git-el, a `git status` paranccsal, de nem fog meglepni minket, hogy semmi (hiszen most hoztuk csak létre a projektet).
+
+```
+git status
+hiba hiba....
+```
+
+A teljesen üres mappánk még nincs verziókezelés alatt. Egy `ls -la`-val ezt ellenőrizni is tudjuk, nem látunk `.git` mappát.
+
+```
+ls -la
+```
+
+#### Git init
+
+Inicializáljuk hát ebbe a mappába a gitet, ezt a beszédes `git init` paranccsal tehetjük meg. Ez beállítja nekünk a `master` branchet és még jó pár alap dolgot (a branch-ről majd később beszélek még, egyelőre annyit elég tudni, hogy ide kerülnek a mentéspontok sorban, mint egy fa ága, innét jön a branch elnevezés).
+
+```
+git init
+```
+
+Ha megint megnézzük az `ls -la` paranccsal, mostmár van egy `.git` mappánk. Ebben benne van minden adatunk a repoval kapcsolatban.
+
+Amikor egy távoli repo-t leszedünk, akkor ezt a `.git` mappát kapjuk meg, és ennek tartalmából már a gépünkön található git alkalmazás előállítja nekünk a master ág legutóbbi mentéspontját.
+
+#### Mentéseink tárolása
+
+A mentések tárolásának fajtáiról a jegyzetben olvashattok, itt annyit említenék csak meg, hogy a git minden, azaz tényleg minden fájlt lemásol, ami verziókezelés alatt áll. Azaz, ha feltöltünk egy 1 GiB-os videót, majd a következő mentéskor átnevezem a videót, akkor már 2 GiB-nyi videót fog tartalmazni a repónk. Ha ez megijesztett minket és megpróbálnánk letörölni, ettől még a repóban ugyanúgy benne lesz, méretet nem csökentünk vele, persze utólag vissza tudunk menni az adott mentéshez, és kitörölni belőle...
+
+Nézzül meg, mi a helyzet a jelenlegi repónkkal.
+
+```
+git status
+```
+
+Láthatjuk, hogy még nincs semmilyen mentéspontunk, nincs mit elmentenünk. Megfigyelhetjük, hogy a git próbál segíteni nekünk (ezt jó sok helyen láthatjuk majd).
+
+Vegyünk fel egy új fájlt:
+
+```
+echo alma > gyumolcskosar
+```
+
+Újra megnézve a git status-t, láthatjuk, megjelent a fájlunk, de még nincs verziókezelés alatt.
+
+#### Git status-ok
+
+Milyen állapotok léteznek egy repo-ban?
+
+Van az:
+
+- Untracked: Ami még nincs verziókontroll alatt
+- Staged: Ami már verziókontroll alatt van de még nem
+  készítettünk róla pillanatképet
+- Unmodified: Amit már elmentettünk és azóta nem változott
+- Modified: Az a fájl, ami már verziókontroll alatt van
+  és változott. Ezt utánna szintén Stage-be tudjuk tenni
+
+Láthatjuk, hogy a git megint próbál segíteni nekünk, írja is, hogy ahhoz hogy verziókövetve legyen a fájlunk, használjuk a `git add` parancsot.
+
+Adjuk is ki:
+
+```
+git add gyumolcskosar
+```
+
+Itt a gyümölcskosár helyett írhattam volna simán . -ot, akkor a repo-ban található összes fájlt bele tette volna (kivéve persze, amit megtíltunk neki, erről is kicsit később).
+
+Mostmár, ha `git status`-t hívunk, megjelenik a gyümölcskosarunk, új fájlként,  `staged` állapotba került, akár el is tudjuk menteni. A mentéshez a `git commit` parancsot adjuk ki. Ekkor megnyílik az előre beállított szövegszerkesztőnk, valamint némi információ a leendő mentéspontról.
+
+```
+git commit
+```
+
+Láthatjuk, amit a `git status` írna ki, valamint pár segítséget a git-től.
+A #-el kezdődő sorok kommentek, ezek a commit üzenetbe nem kerülnek bele, ezek csak nekünk szólnak.
+
+Írjuk is be az első sorba, hogy Készítettem egy gyümölcskosarat, majd mentsük el a fájlt, zárjuk b e a szövegszerkesztőt.
+
+A git érzékelte, hogy bezártuk a fájlt, abból kiolvasta a # nélküli sorokat és hozzáadta a mentéspontunkhoz, mint üzenet, valamint megjelent pár *hasznos* infó is.
+
+Nézzük, most mi a helyzet a repoban?
+
+```
+git status
+```
+
+Már nem szól semmit amiatt, hogy nincs mentésünk (hiszen az előbb készítettünk egyet), továbbá azt is írja, hogy nincs semmi amin változtattunk volna, azaz erről az állapotról nem is tudnánk új mentést készíteni (megegyezne az korábbival).
+
+Nézzük meg a következő két állapotot is, amiben egy fájl lehet. Írjuk bele a gyümölcskosarunkba, hogy már körte is van benne.
+
+```
+echo körte >> gyumolcskosar
+```
+
+Adjuk ki a `git status`-t:
+
+Láthatjuk, hogy mostmár `modified` állapotba került a gyümölcskosarunk. Mentsük is el, de egy kicsit kényelmesebb módon.
+
+```
+git add gyumolcskosar
+git commit -m "Raktam bele körtét is"
+```
+
+Fontos, ne felejtsük el először hozzáadni a fájlunkat a stage-hez, a `git add gyumolcskosar` paranccsal.
+
+Készítsünk egy új fájlt `hordo` névvel, és nézzük meg, mit ír ki a `git status -s` parancs. Ezzel a kapcsolóval képesek vagyunk egy rövidített státuszt lekérni.  
+
+Add-oljuk, majd commit-oljuk el.
+
+```
+git add hordo
+git status -s
+git commit -m "Hoztunk egy hordót"
+```
+
+#### Gitignore
+
+Oké, de mi van, ha nagyon nem szeretnénk, ha egy fájlunk verziókezelés alatt állna? Mondjuk a build-ek mappái, egy IDE által generált fájlokra, esetleg a gites előadás jegyzeteimre.
+
+Hozzunk létre egy `jegyzeteim.txt`-t és egy `.gitgnore`-t
+
+```
+touch jegyzeteim.txt
+touxh .gitgnore
+```
+
+Ha kiadjuk a `git status` parancsot, megjelenik a jegyzeteim.
+
+Írjuk bele a a jegyzeteim.txt-t a gitignore-ba.
+
+```
+echo jegyzeteim.txt >> .gitignore
+```
+
+Adjuk ki *megint* a `git status` parancsot. Oh, eltűnt a jegyzetünk! Pont ezt akartuk, mostmár a git nem fogja figyelni ezt a fájlt.  
+Add-oljuk és mentsük el a gitignore-t.
+
+```
+git add .gitignore; git commit -m "jegyzeteim ignorálása"
+```
+
+#### Fájlok mozgatása
+
+A git nem tárol semmi adatot változásokról, csak mentéseket készít. Próbáljuk ki, mi történik, ha átnevezünk egy fájlt?
+
+```
+mv gyumolcskosar gyumolcskosar.txt
+```
+
+Toljunk egy `git status`-t.
+
+Láthatjuk, hogy az eredeti fájlt "töröltük", és sikeresen létrehoztunk egy új fájlt a repoban. Nézzük meg, mi történik, ha add-oljuk a változtatásokat.
+
+```
+git add .
+git status
+```
+
+Persze a szokásos `git status` sem maradhat el. Mostmár látszik, hogy átnevezés történt.##
+
+A git képes rá, hogy felismerjea fájlokat és eldöntse, hogy a két fájl ugyanaz, csak átneveztük, mozgattuk, etc.. Követni nem tudja, csak azt látja, hogy létrejött egy új fájl, mint ami törölve lett nemrég.
+
+#### Mentési előzmények
+
+A git egyik leghasznosabb parancsa a `git status` után a `git log`.
+
+Próbáljuk is ki:
+
+```
+git log
+```
+
+Láthatjuk, milyen mentéspontjaink vannak, és a hozzájuk tartozó dolgokat, mint a commit hash vagy az üzenet.
+
+Picit szebbé is tehetjük, ha kiadjuk a parancsot a `--oneline` kapcsolóval.
+
+```
+git log --oneline
+```
+
+Máris csak a lényeget látjuk. Azt is észre vehetjük, csak 7 karaktert kapunk a hash-ből. ELég csak pár karakter, hogy be tudjuk azonosítani a commit-ot.
+
+## Branch-ek, elágazás
+
+### Mik azok a branch-ek?
+
+Korábban már említettem a branch-et, mint fogalmat. Képzeljük el a git-et, hogy szeretne adatokat, mutatókat tárolni. Mi van akkor, ha egy mutatóból kétfelé is elindulunk? Mondjuk Rick és én elkezdünk együtt kódolni...
+Képzeljük el úgy, mint egy fa törzse, melyből ágak jönnek létre. Készítünk egy ágat Rick-nek és egyet nekem. Így tudunk ketten külön dolgozni, míg a master-t nem piszkáltuk.  
+Úgy is el lehet képzelni egy nagyobb projektnél, hogy van a master, amin az éles, jól működő kód van, és van a fejlesztési ág, amin pedig a fejlesztők dolgoznak (ez így azért még nagyon leegyszerűsíti).
+
+Nézzünk is egy példát, adjuk ki a `git status` parancsot.
+
+```
+git status
+```
+
+Látható, hogy jelenleg a `master` ágon vagyunk. Nézzük meg, milyen branch-ek vannak most a repónkban.
+
+```
+git branch
+```
+
+Még csak eyg águnk van. Ha kiadjuk a `git branch <új branch neve>` parancsot, akkor készül egy új ág, de arra figyeljünk, ilyenkor még nem megyünk át rá.
+Nézzük is meg, hogy tényleg elkészült, a `git branch` paranccsal.
+
+```
+git branch atnevezes
+git branch
+```
+
+Itt a `*` azt jelöli, hogy éppen melyik branch-en vagyunk. Ha kiadnánk a `git status`-t, amit most nem teszünk meg, ne koptassuk el szegényt, ugyanúgy láthatánk, melyik ágon vagyunk.
+
+Menjünk át az új ágra.
+
+```
+git checkout atnevezes
+```
+
+Itt rögtön látjuk is, a módosításainkkal nem történt semmi. Ha most elmentjük őket, akkor a jelenlegi ágra fogja beilleszteni őket.
+
+```
+git add .
+git status
+git commit -m "Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz"
+```
+
+Most ha kiadjuk a `git log --graph --oneline` parancsot, akkor meg is láthatjuk, hogy néz ki a fánk.
+
+### Hogyan épülnek fel?
+
+Ezt nézzétek meg a jegyzetben, röviden annyit, hogy mutatókat, pointereket használ a git, minden mentéspont az előzőre mutat, valamint a megfelelő fájlokra, amiket módosítottunk.
+
+### Ágak közötti mozgás
+
+Mielőtt visszatérnénk a master-re, nézzük meg, milyen fájljaink vannak.
+
+```
+ls -la
+```
+
+A gyumolcskosar.txt a lényeges.
+
+Térjünk vissza a master-re, és adjuk ki megint az `ls -la`-t.
+
+```
+git checkout master
+ls -la
+```
+
+Látható, hogy visszaléptünk pontosan abba az állapotba, ami volt, mielőtt eljöttünk volna, azaz a gyümölcskosarat nem is változtattuk meg. Ez azért jó, mert két teljesen elkülönülő munkát szét tudunk választani.
+
+Írjuk a gyümölcskosár végére, hogy szőlő és mentsük is el.
+
+```
+echo szolo >> gyumolcskosar
+git add .
+git commit -m "Tettem bele szőlőt is"
+```
+
+Most kiadva a `git log --graph --oneline`-t már egy érdekesebb eredményt láthatunk.
+
+Hová tűnt a fájlunk? A git nem fogja alapból jelezni nekünk azt, amit nem lát a jelenlegi mentésből visszamenve.
+Ahhoz hogy lássuk a másik ágat is, tegyük hozzá a `--all` kapcsolót.
+
+```
+git log --graph --oneline --all
+```
+
+Nah, rögtön látjuk a másik ágat is.  
+
+Menjünk vissza az átnevezés ágra sé módosítsuk kicsit.
+
+```
+git checkout atnevezes
+```
+
+Nevezzük át a hordót hordó.txt-re, majd mentsük is el a munánkat.
+
+```
+mv hordo hordo.txt
+git add .
+git commit -m "Adtam kiterjesztést a hordónak is"
+```
+
+Egy megismételt `git log`-al láthatjuk is a fánkat.
+
+```
+git log --graph --oneline --all
+```
+
+### Merge-elés
+
+Az egyik legfontosabb dolog az ágak létrehozása után, hogy azokat be is tudjuk olvasztani valahova. A feladat az lenne, hogy a masterre beillesszük az átnevezés ágon végzett módosításokat.  
+Ehhez a `git merge <branch neve>` parancsot használhatjuk. Ez a parancs a kiválasztott ágat megpróbálja beolvasztani oda, ahol jeleneleg a `HEAD` mutatónk van.  
+
+Menjünk is vissza a masterre. és próbáljuk meg merge-elni az átnevezés ágat.
+
+
+```
+git checkout master
+git merge atnevezes
+```
+
+Ekkor meg fog nyílni a szövegszerkesztőnk, ugyanis egy
+új mentéspontot fogunk készíteni a `master` águnkra.
+A feladott merge üzeneten nem kell módosítanunk, teljesen
+jó így.
+
+A merge lefut és láthatjuk mi is történt.
+Most egy újabb `git log --graph --oneline --all`-al ezt láthatjuk.
+Ez a merge commit egyszerre mutat két ágra is.
+
+#### Merge conflict
+
+Mi van akkor, ha ketten egyszerre ugyanazat változtatjuk?
+Úgy döntöttünk, Rick barátommal szeretnénk pálinkát főzni, szóval a hordóba teszzük ízlás szerint pár gyümölcsöt.
+
+Menjünk át a saját branch-ünkre.
+
+```
+git checkout -b blint
+```
+
+A -b kapcsolóval létre tudunk hozni nemlétező branch-et a checkout-nak megadva.
+
+Ha kiadjuk megint a `git branch`-et, láthatjuk, már három ág is van.
+
+Tegyünk bele a hordóba egy nekünk tetsző gyümölcsöt.
+
+```
+echo korte >> hordo.txt
+```
+
+Mentsül is el. A -a kapcsolóval egy lépést megint meg tudok spórolni.
+
+```
+git commit -a -m "Raktam bele körtét"
+```
+
+Rick eközben úgy döntött, ugyanebbe a hordóba szilvát szeretne tenni. Menjünk át a master-re és tegyük meg ott.
+
+Tehát:
+```
+git checkout master
+echo szilva >> hordo.txt
+git commit -a -m "Raktam bele szilvát"
+```
+
+Ha megnézzük megint a gráfunkat, láthatjuk mi a helyzet jelenleg a reponkban.
+
+```
+git log --graph --oneline --all
+```
+
+Hát most próbáljuk meg merge-lni.
+
+```
+git merge blint
+```
+
+Oh, no, merge conflict keletkezett.
+Nem kell megijedni, nem a világ vége és a git segít ahol tud.
+
+Az a helyzet, hogy egyszerre ugyanazt a sort módosítottuk és a git nem tudta
+eldönteni mit tegyen. Megtartsa az egyiket vagy mindkettőt? Mégis mi legyen?
+
+Ezeket a kérdéseket nekünk kell megválaszolnunk.
+
+Először nézzük meg, mi a státusz.
+
+```
+git status
+```
+
+Ilyenkor a git beírja a fájlba mindkét branch változatát, ezt meg is jelöli nekünk, és tőlünk várja a megoldást.
+
+Nincs mit tenni, mint kitalálni, hogy mi maradjon a fájlban.
+
+Itt láthatjuk nyilakkal a HEAD és a blint branch által eszközölt módosításokat, egyenlőségjellel elválasztva egymástól.
+
+Csináljunk egy vegyes pálinkát, legyen benne mind a kettő.
+
+Ha megnézzük a státuszt, láthatjuk, még mindig ugyanaz a helyzet, mint korábban. Amíg nem mentjük el a módosításunkat, addig ezt fogja kiírni.
+
+```
+git commit -a -m "blint branch mergelve és konflikt megoldva"
+```
+
+Nézzük meg a gráfot ezután.
+
+```
+git --graph --oneline --all
+```
+
+Látjuk, a merge commit-unk egyben a konfliktus megoldását is tartalmazza.
+
+Most hogy tudjuk az alapokat, már csak mindezt közösen kell végezzük, online. Erről majd a gyakorlaton lesz szó.
+
+Addig is szép hétvégét, hetet, ki mikor nézi meg kívánok nektek!
\ No newline at end of file

guide/intro/1_intro.md

@@ -8,10 +8,8 @@ hogy a jövőben ne okozzon problémát a verziókezelés.
 Olyan kérdésekre fogok választ adni, mint "Miért kell
 git-et használnom?", "Miért ilyen bonyolult ez az egész?"
 és "Mégis mi a francot nyerek ezzel?".
-Ja és előre is bocsi a helyesírási hibákért, várom majd
-a javításokat a dokumentáció [git repo-jába](https://github.com/rlacko58/gitPresentation) :)
 
-Amire szükséged lesz: Egy konzol működő git-el ([Workshop elején](workshop/1_installation.md)
+Amire szükséged lesz: Egy konzol, működő git-el ([workshop elején](../workshop/1_installation.md)
 van egy útmutató)
 
 ## Tippek
@@ -24,18 +22,15 @@ belefektett munkát.
 
 ## Ki vagyok én?
 
-Rafael László (Lackó), harmadéves mérnökinformatikus
-szoftverjlesztő speces hallgató.
-Jelenleg a DevTeam körvezetője, de a KSZK többi körében
-is aktívan tevékenykedem.
-Manapság főleg webfejlesztéssel foglalkozom,
-olyan projekteken dolgoztam, mint az AdminSCH
-vagy a KSZK Újonc weboldala.  
+Réthelyi Bálint (Blint), másod éves infós, jelenleg a reszortgazdaságis és kancellár, emellett lelkes szerversimogató és DevOps-os.
+Van pár [DevTeam](https://git.sch.bme.hu/kszk/devteam)ben megtalálható projektem ([hőmérőSCH](https://git.sch.bme.hu/kszk/devteam/statusch/homerosch) és [becskasszáSCH](https://git.sch.bme.hu/kszk/devteam/becskasszasch)).  
+
 Ha bármi kérdésed merülne fel a doksi olvasása vagy az előadás
 során nyugodtan keress meg
 
-- Emailben: laszlo.rafael [kukac] kszk.bme.hu
+- Emailben: rethelyi.balint [kukac] kszk.bme.hu
 
 <div style="text-align:center"><img src="guide/intro/img/me.jpg" alt="Kép magamról" /></div>
 
-Forrás: [Pro Git könyv](https://git-scm.com/book/en/v2/)
+Forrás: [Pro Git könyv](https://git-scm.com/book/en/v2/)  
+Forrás2: [Rafael László (Lackó) git-es jegyzete](https://home.sch.bme.hu/~rlacko/git/)

guide/intro/2_versioning.md

@@ -5,10 +5,10 @@ Talán a legegyszerűbb egy példán keresztül szemléltetni.
 Tegyük fel egy docx fájlt szerkesztünk és ezt hetente
 frissítve rendszeresen el kell küldenünk emailben valakinek.
 Ilyenkor különböző verziók keletkeznek a fájlból és ezeket
-a postafiókunkból könnyedén előtudjuk szedni.
+a postafiókunkból könnyedén elő tudjuk szedni.
 
-Na ugyanazen a példán tovább mehetünk.
-Mi van ha lokális kezdjük ezeket a fájlokat tárolni?
+Na ugyanazen a példán tovább mehetünk.  
+Mi van ha lokális kezdjük ezeket a fájlokat tárolni?  
 Gondolom mindenki találkozott már hasonló fájlnevekkel:
 
 ```
@@ -25,8 +25,8 @@ Gondolom mindenki találkozott már hasonló fájlnevekkel:
 Ha ügyesek vagyunk még mappákat is készítünk és dátumot is hozzá cimkézünk.
 
 ```
-└── 2020
-    └── 09
+└── 2021
+    └── 02
         ├── 13
         │   └── elso_beadasom.docx
         ├── 19
@@ -54,33 +54,33 @@ kézileg tettük.
 
 #### Helyi
 
-Erre a fenti példa legjobb példa.
+Erre a fenti példa a legjobb példa.  
 Vannak különböző verziói a fájlunknak és ezeket valamilyen
 adatbázisban rögzítjük.
 
-<div style="text-align:center"><img src="intro/img/vcstype_local.png" alt="Local Version Control Systems" /></div>
+<div style="text-align:center"><img src="guide/intro/img/vcstype_local.png" alt="Local Version Control Systems" /></div>
 
-Ilyen az [RCS](https://www.gnu.org/software/rcs/)
+Ilyen az [RCS](https://www.gnu.org/software/rcs/).
 
 ### Központosított
 
 Ez már egy fokkal okosabb.
 A különböző verziókat a központi szerverre rakjuk fel és
-onann szedjük le.
+onnan szedjük le.  
 Például van egy Fájlszerverünk amit minden gépről elérnek
-az emberek és oda dolgoznak közösen.  
+az emberek és oda dolgoznak közösen...  
 Érezhető probléma, hogy így ha meghal a központi szerver,
-akkor mindent elvesztünk.
+akkor mindent elvesztünk (eskü nem volt még ilyen 😅).  
 Továbbá probléma lehet, hogy egymás munkáját felülírjük,
 szerencsére egy jó rendszernél erről értesítést kapunk,
 hozzá és nem felülírjuk a módosításaink.
 
-<div style="text-align:center"><img src="intro/img/vcstype_central.png" alt="Centralized Version Control Systems" /></div>
+<div style="text-align:center"><img src="guide/intro/img/vcstype_central.png" alt="Centralized Version Control Systems" /></div>
 
 ### Megosztott
 
 Na és itt lépünk be a ma is használt Git világába.
-Ennél a megoldásnál már az a trükk, hogy mindenkinek meg van
+Ennél a megoldásnál már az a trükk, hogy mindenkinek megvan
 a teljes projekt az összes verziójával. Felmerül, hogy na
 de akkor honnan szedjük le a legújabb verziót?
 Különböző megoldások léteznek, például a fejlesztők a
@@ -88,8 +88,8 @@ módosításokat azonnal megosztják egymással
 (pl.: p2p Torrenthez hasonló módon) vagy
 kijelölnek egy központi szervert amivel mindenki
 szinkronban van.
-Ilyen központi szerver lehet például a Github vagy a Gitlab.  
-Csak megjegyzem, de akár a módosításokat Emailben is ellehet
-küldeni és a szoftver automatikusan megcsinálja a többi a mi részünkön.
+Ilyen központi szerver lehet például a [Github](https://github.com/) vagy a [Gitlab](https://gitlab.com/).  
+Csak megjegyzem, akár a módosításokat emailben is el lehet
+küldeni és a szoftver automatikusan megcsinálja a többit a mi részünkön.
 
-<div style="text-align:center"><img src="intro/img/vcstype_distributed.png" alt="Distributed Version Control Systems" /></div>
+<div style="text-align:center"><img src="guide/intro/img/vcstype_distributed.png" alt="Distributed Version Control Systems" /></div>

guide/intro/3_history.md

@@ -14,7 +14,7 @@ Aztán 2002-től egy zárt licenszű verzió kezelőre, a
 Ezt a Linux fejlesztői ingyen használhatták egészen 2005-ig,
 mikorra annyira elromlott a kapcsolat a fejlesztők és a cég
 között, hogy elvették tőlük a licenszt.
-Az i-re a pontott az tette le, mikor az egyik
+Az i-re a pontott az tette fel, mikor az egyik
 kernel fejlesztő
 [reverse engineer-elte](https://lwn.net/Articles/132938/)
 a BitKeeper-t.  
@@ -22,11 +22,11 @@ Ekkoriban
 [Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds)
 úgy döntött, hogy egy új megoldást kell találnia, mely
 
-- Gyors
-- Egyszerű
-- Támogatja a többszálú fejlesztést
-- Teljesen elosztott
-- Nagy projekteket is képes kezelni (pl.: Linux kernel)
+- gyors
+- egyszerű
+- támogatja a többszálú fejlesztést
+- teljesen elosztott
+- nagy projekteket is képes kezelni (pl.: Linux kernel)
 
-Így hát megírta a [Git-et](https://en.wikipedia.org/wiki/Git), mely a mai napig a legelterjedtebb, leggyorsabb és
-legkényelmesebb verzió kezelő rendszerünk.
+Így hát megírta a [Git](https://en.wikipedia.org/wiki/Git)-et, mely a mai napig a legelterjedtebb, leggyorsabb és
+legkényelmesebb verzió kezelő rendszer.

guide/workshop/1_installation.md

@@ -50,7 +50,7 @@ Legegyszerűbben ezzel a paranccsal lehet a jelenlegi konfig
 fájlok helyzetét kiírni:  
 `git config --list --show-origin`
 
-Látható, hogy a konfigok valamilyen config fájlba menti
+Látható, hogy a konfigokat valamilyen config fájlba menti,
 a fájlrendszerben elszórva. Erről egy pár táblázat:
 
 ##### Windows
@@ -79,8 +79,16 @@ Nálam a konfig a home mappámban például így néz ki:
 ```
 $ cat ~/.gitconfig
 [user]
-        email = rlacko99 [AT] gmail.com
-        name = Rafael László
+        name = Bálint Réthelyi
+        email = rethelyibalint@gmail.com
+        signingkey = 6EA0C1AC38C567DE
+[core]
+        editor = nvim
+        autocrlf = input
+[pull]
+        rebase = true
+[commit]
+        gpgsign = true
 ```
 
 ### Állítsuk be a dolgokat magunknak
@@ -116,12 +124,13 @@ Nézzük meg az összes beállításunk:
 
 ```
 $ git config --list
-user.email=rlacko99 [AT] gmail.com
-user.name=Rafael László
-core.repositoryformatversion=0
-core.filemode=true
-core.bare=false
-core.logallrefupdates=true
+user.name=Bálint Réthelyi
+user.email=rethelyibalint@gmail.com
+user.signingkey=6EA0C1AC38C567DE
+core.editor=nvim
+core.autocrlf=input
+pull.rebase=true
+commit.gpgsign=true
 ...
 ```
 
@@ -129,5 +138,5 @@ Ha pedig csak egy adottat szeretnénk:
 
 ```
 $ git config user.name
-Rafael László
+Bálint Réthelyi
 ```

guide/workshop/2_basics.md

@@ -45,11 +45,11 @@ Tehát az a mappa, ahol van egy .git mappa, az egy git repo.
 ```
 $ ls -al
 total 20
-drwxrwxr-x 4 rlacko rlacko 4096 okt 8 12:59 .
-drwxrwxr-x 3 rlacko rlacko 4096 okt 7 12:04 ..
-drwxrwxr-x 5 rlacko rlacko 4096 okt 7 12:46 docs
-drwxrwxr-x 8 rlacko rlacko 4096 okt 8 16:39 .git
--rw-r--r-- 1 rlacko rlacko 17 okt 7 12:09 README.md
+drwxrwxr-x 4 blint blint 4096 okt 8 12:59 .
+drwxrwxr-x 3 blint blint 4096 okt 7 12:04 ..
+drwxrwxr-x 5 blint blint 4096 okt 7 12:46 docs
+drwxrwxr-x 8 blint blint 4096 okt 8 16:39 .git
+-rw-r--r-- 1 blint rlacko 17 okt 7 12:09 README.md
 
 ```
 
@@ -88,7 +88,17 @@ egy fa ága.
 
 ```
 $ git init .
-Initialized empty Git repository in .../projektem/.git/
+hint: Using 'master' as the name for the initial branch. This default branch name
+hint: is subject to change. To configure the initial branch name to use in all
+hint: of your new repositories, which will suppress this warning, call:
+hint: 
+hint:   git config --global init.defaultBranch <name>
+hint: 
+hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
+hint: 'development'. The just-created branch can be renamed via this command:
+hint: 
+hint:   git branch -m <name>
+Initialized empty Git repository in /home/blint/Projects/random codes/git_pres_working_dir/projektem/.git/
 
 ```
 
@@ -97,9 +107,9 @@ Ha megnézzük, mostmár van egy .git mappánk
 ```
 $ ls -al
 total 12
-drwxrwxr-x 3 rlacko rlacko 4096 okt 8 16:52 .
-drwxrwxr-x 12 rlacko rlacko 4096 okt 8 16:49 ..
-drwxrwxr-x 7 rlacko rlacko 4096 okt 8 16:52 .git
+drwxr-xr-x 3 blint blint 4096 Mar 19 12:40 .
+drwxr-xr-x 3 blint blint 4096 Mar 19 12:39 ..
+drwxr-xr-x 7 blint blint 4096 Mar 19 12:40 .git
 
 ```
 
@@ -136,9 +146,9 @@ majd a következő mentéskor pár bitet átírok, akkor már
 2gb-nyi videó lesz a repóban és ha utána egy másik mentésel
 ki is töröljük, az attól még megmarad.
 Persze utólag tudunk olyat, hogy visszmegyünk és kitöröljük
-az adott mentésből.
+az adott mentésből (ezért nem jó ötlet git repo-ba 100 GB-os vm image-t felpush-olni, majd letörölni, hogy oops ez véletlen volt srácok).
 
-Oké, tehát például mappákba bemásolja a mentéseinket valamilyen
+Oké, tehát például a mappákba bemásolja a mentéseinket valamilyen
 módon, de mégis hova?
 
 ```
@@ -171,18 +181,18 @@ Hash-t láthatunk például a mentéspontjainkon, fájljainkon, stb.
 Például itt egy ábra, hogy hogyan társítja a git egy
 commit-hoz a megfelelő fájlokat egy kis pointer mágia keretében.
 
-<div style="text-align:center"><img src="workshop/img/commit-and-tree.png" alt="Commit and Tree" /></div>
+<div style="text-align:center"><img src="guide/workshop/img/commit-and-tree.png" alt="Commit and Tree" /></div>
 
 Ennél jobban nem megyek bele a témába, de érdekes olvasmány.
 
 #### Változtatások mentése
 
-Hogyan néz ki egy mentés?
+Hogyan néz ki egy mentés (a `git log`-al tudod megnézni)?
 
 ```
-commit c45abc3d64c7840b4088b77d5a60d02198a78854
-Author: Rafael László <rlacko99 [AT] gmail.com>
-Date:   Thu Oct 8 17:19:28 2020 +0200
+commit e334ae2e8c4104429ff034152e622851a25c3a97
+Author: blint <blintmester@sch.bme.hu>
+Date:   Thu Mar 18 15:37:54 2021 +0100
 
     Készítettem egy gyümölcskosarat
 ```
@@ -204,7 +214,7 @@ repo-ban.
 
 Nézzük meg ezen az ábrán és egy példa projekten keresztül:
 
-<div style="text-align:center"><img src="workshop/img/git_lifecycle.png" alt="Git Life cycle" /></div>
+<div style="text-align:center"><img src="guide/workshop/img/git_lifecycle.png" alt="Git Life cycle" /></div>
 
 Mi a jelenlegi helyzet a frissen inicializált repo-ban?
 
@@ -246,10 +256,10 @@ nothing added to commit but untracked files present (use "git add" to track)
 ```
 
 Ahhoz, hogy git alá helyezzük, a `git add <fájl>` parancsot
-fogjuk kiadni.
+fogjuk kiadni.  
 _Ezek a parancsok mind képesek rá, hogy
 Unix-os módon több fájlra is kiadhatóak legyenek.
-Például a `<fájl>` lehet `*.jpg`amivel minden .jpg fájlt kijelölünk a jelenlegi mappában"_ - Linux magic #02
+Például a `<fájl>` lehet `*.jpg`amivel minden .jpg fájlt kijelölünk a jelenlegi mappában._ - Linux magic #02
 
 ```
 $ git add gyumolcskosar
@@ -319,7 +329,7 @@ mit elmenteni.
 Nézzük meg a további két állapotot is amiben lehet egy fájl.
 Írjuk bele a gyumolcskosar fájlba, hogy `korte`
 
-```gyumolcskosar
+```
 alma
 korte
 ```
@@ -339,7 +349,7 @@ no changes added to commit (use "git add" and/or "git commit -a")
 
 Látható, hogy mostmár `modified` a fájlunk, mentsük is el,
 de most picit másképp. A git és általában minden Unix
-parancsnak áttudunk adni úgynevezett kapcsolókat.
+parancsnak át tudunk adni úgynevezett kapcsolókat.
 Például `git commit -m <message>`.
 Ez annyit spórol meg nekünk, hogy nem kell szövegszerkesztőt
 megnyitnia a git-nek mikor új commit-ot készítünk,
@@ -349,8 +359,12 @@ hogy várjon egy szöveget, mint mentéshez kapcsolódó üzenet.
 `-m: message, -a: all`, de tudunk hosszabb verziókat is
 használni, mint `--message, --all`.
 
-> Ne felejtsük el először stagelni a mentendő fájljaink egy
-> `git add <fájl>` parancs kiadásával.
+<Note type="warning" label="Megjegyzés">
+
+Ne felejtsük el először stagelni a mentendő fájljaink egy
+`git add <fájl>` parancs kiadásával.
+
+</Note> 
 
 ```
 $ git add gyumolcskosar
@@ -381,7 +395,19 @@ Láthatjuk, hogy a `jegyzeteim` fájl megjelent.
 
 Most írjuk be a fájl nevét a `.gitignore`-ba.
 
-```.gitignore
+<Note type="tip" label="Tipp">
+
+```shell-session
+echo jegyzeteim.txt >> .gitingore
+```
+
+Itt a >> a hozzáfűzés miatt kell, hasznos ha nem írjuk felül az egész fájlt.
+
+</Note>
+
+
+`.gitignore`:
+```
 jegyzeteim.txt
 ```
 
@@ -420,7 +446,7 @@ Látható, hogy az eredeti fájlt "töröltük" és egy új
 fájlt vettünk fel a repo-ba. Érdekes, mi lenne ha stagelnénk
 a változtatásokat `git add .` -al?
 
-```
+```shell-session
 $ git add .
 $ git status
 On branch master
@@ -442,27 +468,27 @@ A Git egyik legjobb parancsa a `git log` a `git status` után és
 szeretném ha kipróbálnád.
 
 ```
-commit 80560db1f5a83496b80f1959fbcbae2ccfff320e (HEAD -> master)
-Author: Rafael László <rlacko99 [AT] gmail.com>
-Date:   Thu Oct 8 21:07:25 2020 +0200
+commit 996698cf3273800680c351df950ebe1fbaf5182a (HEAD -> master)
+Author: Bálint Réthelyi <rethelyibalint@gmail.com>
+Date:   Sat Mar 20 13:02:20 2021 +0100
 
     jegyzeteim ignorálása
 
-commit 30bf35d36399e484b03090570e13cb95da92ab8b
-Author: Rafael László <rlacko99 [AT] gmail.com>
-Date:   Thu Oct 8 20:11:58 2020 +0200
+commit 36552bc9400d94f399bd505a566178a4c83e8abd
+Author: Bálint Réthelyi <rethelyibalint@gmail.com>
+Date:   Sat Mar 20 13:00:32 2021 +0100
 
-    Hoztunk egy hordót
+    Hoztunk egy hordót is
 
-commit b677a8639193479157f7a576dffe0186b0dbe2c8
-Author: Rafael László <rlacko99 [AT] gmail.com>
-Date:   Thu Oct 8 17:33:07 2020 +0200
+commit a8a9b268e50a784fb2e3c0d7422d4d8ccd638b64
+Author: Bálint Réthelyi <rethelyibalint@gmail.com>
+Date:   Sat Mar 20 12:59:32 2021 +0100
 
     Raktam bele egy körtét
 
-commit c45abc3d64c7840b4088b77d5a60d02198a78854
-Author: Rafael László <rlacko99 [AT] gmail.com>
-Date:   Thu Oct 8 17:19:28 2020 +0200
+commit 2a685fcd1e66b11805570869f8f49d5c5ef3bca1
+Author: Bálint Réthelyi <rethelyibalint@gmail.com>
+Date:   Sat Mar 20 12:12:40 2021 +0100
 
     Készítettem egy gyümölcskosarat
 ```
@@ -475,10 +501,10 @@ Picit tegyük szebbé. Adjuk ki az előző parancsot a
 `--oneline` kapcsolóval.
 
 ```
-80560db (HEAD -> master) jegyzeteim ignorálása
-30bf35d Hoztunk egy hordót
-b677a86 Raktam bele egy körtét
-c45abc3 Készítettem egy gyümölcskosarat
+996698c (HEAD -> master) jegyzeteim ignorálása
+36552bc Hoztunk egy hordót is
+a8a9b26 Raktam bele egy körtét
+2a685fc Készítettem egy gyümölcskosarat
 ```
 
 Máris csak a lényeget látjuk. Az is látható, hogy csak 7

guide/workshop/3_branch.md

 # Branch-ek, elágazás
 
-#### Mik azok a branch-ek?
+## Mik azok a branch-ek?
 
 Talán legegyszerűbb, ha előbb készítünk egyet.
 
@@ -82,7 +82,7 @@ Mentsük el ide a módosításaink
 
 ```
 $ git commit -m "Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz"
-[atnevezes 7de1c94] Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
+[atnevezes 07ac740] Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
  1 file changed, 0 insertions(+), 0 deletions(-)
  rename gyumolcskosar => gyumolcskosar.txt (100%)
 ```
@@ -91,20 +91,20 @@ Ezt követően ha kiadjuk a `git log --graph --oneline` parancsot, akkor
 meg is láthatjuk a jelenlegi helyzetet a mi fánkban:
 
 ```
-* 7de1c94 (HEAD -> atnevezes) Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
-* 80560db (master) jegyzeteim ignorálása
-* 30bf35d Hoztunk egy hordót
-* b677a86 Raktam bele egy körtét
-* c45abc3 Készítettem egy gyümölcskosarat
+* 07ac740 (HEAD -> atnevezes) Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
+* 996698c (master) jegyzeteim ignorálása
+* 36552bc Hoztunk egy hordót is
+* a8a9b26 Raktam bele egy körtét
+* 2a685fc Készítettem egy gyümölcskosarat
 ```
 
-#### Hogy épül fel?
+## Hogy épül fel?
 
 Először is, ahhoz hogy tudja a git melyik mentéspont után
 melyik jön, mutatókat használ ehhez az ábrához
 hasonló módon:
 
-<div style="text-align:center"><img src="workshop/img/commits-and-parents.png" alt="Commits and parents" /></div>
+<div style="text-align:center"><img src="guide/workshop/img/commits-and-parents.png" alt="Commits and parents" /></div>
 
 A mentéspontjaink az előzőre mutatnak.
 Ahogy láthattuk az előző fejezetben, a mentéspontok pedig
@@ -113,7 +113,7 @@ mutatnak a megfelelő fájlokra amiket épp módosítottunk.
 Vizsgáljuk meg a jelenlegi repo-nkat, hogy pontosan
 mi merre is van.
 
-<div style="text-align:center"><img src="workshop/img/tree_with_one_branch.png" alt="Tree with one branch" /></div>
+<div style="text-align:center"><img src="guide/workshop/img/tree_with_one_branch.png" alt="Tree with one branch" /></div>
 
 A mentéspontok képesek mutatni az előzőre, ezt láthatjuk
 az ábrán.
@@ -133,16 +133,16 @@ előtt átváltsunk a megfelelő ágra.
 Még mielőtt vissza mennénk a master-re, nézzük meg milyen
 fájljaink vannak az `ls -al` -el.
 
-```
+```shell-session
 $ ls -al
 total 20
-drwxrwxr-x  3 rlacko rlacko 4096 okt    8 21:07 .
-drwxrwxr-x 12 rlacko rlacko 4096 okt    8 16:49 ..
-drwxrwxr-x  8 rlacko rlacko 4096 okt    9 15:01 .git
--rw-rw-r--  1 rlacko rlacko   15 okt    8 20:43 .gitignore
--rw-rw-r--  1 rlacko rlacko   11 okt    8 17:29 gyumolcskosar.txt
--rw-rw-r--  1 rlacko rlacko    0 okt    8 20:09 hordo
--rw-rw-r--  1 rlacko rlacko    0 okt    8 20:42 jegyzeteim.txt
+drwxr-xr-x 3 blint blint 4096 Mar 20 13:02 .
+drwxr-xr-x 3 blint blint 4096 Mar 19 12:39 ..
+drwxr-xr-x 8 blint blint 4096 Mar 20 13:12 .git
+-rw-r--r-- 1 blint blint   15 Mar 20 13:01 .gitignore
+-rw-r--r-- 1 blint blint   11 Mar 20 12:58 gyumolcskosar.txt
+-rw-r--r-- 1 blint blint    0 Mar 20 12:59 hordo
+-rw-r--r-- 1 blint blint    0 Mar 20 13:01 jegyzeteim.txt
 ```
 
 Egy pár extra adatot is kapunk, de nekünk most a
@@ -151,23 +151,23 @@ Egy pár extra adatot is kapunk, de nekünk most a
 Most gyerünk vissza a `master` ágra a `git checkout <ág neve>`
 paranccsal.
 
-```
+```shell-session
 $ git checkout master
 Switched to branch 'master'
 ```
 
 Most adjuk ismét ki az `ls -al` parancsot.
 
-```
+```shell-session
 $ ls -al
 total 20
-drwxrwxr-x  3 rlacko rlacko 4096 okt    9 15:24 .
-drwxrwxr-x 12 rlacko rlacko 4096 okt    8 16:49 ..
-drwxrwxr-x  8 rlacko rlacko 4096 okt    9 15:24 .git
--rw-rw-r--  1 rlacko rlacko   15 okt    8 20:43 .gitignore
--rw-rw-r--  1 rlacko rlacko   11 okt    9 15:24 gyumolcskosar
--rw-rw-r--  1 rlacko rlacko    0 okt    8 20:09 hordo
--rw-rw-r--  1 rlacko rlacko    0 okt    8 20:42 jegyzeteim.txt
+drwxr-xr-x 3 blint blint 4096 Mar 20 13:16 .
+drwxr-xr-x 3 blint blint 4096 Mar 19 12:39 ..
+drwxr-xr-x 8 blint blint 4096 Mar 20 13:16 .git
+-rw-r--r-- 1 blint blint   15 Mar 20 13:01 .gitignore
+-rw-r--r-- 1 blint blint   11 Mar 20 13:16 gyumolcskosar
+-rw-r--r-- 1 blint blint    0 Mar 20 12:59 hordo
+-rw-r--r-- 1 blint blint    0 Mar 20 13:01 jegyzeteim.txt
 ```
 
 Látható, hogy vissza léptünk arra az állapotra mikor még
@@ -179,9 +179,9 @@ Ez elképesztően jó, ugyanis két teljesen külön álló munkát
 Írjuk a `gyumolcskosar` fájl végére, hogy `szolo` és mentsük el
 azzal az üzenettel, hogy `Tettem a kosaramba szőlőt`.
 
-```
+```shell-session
 $ git commit -m "Tettem a kosaramba szőlőt"
-[master 932cbeb] Tettem a kosaramba szőlőt
+[master c8496bf] Tettem a kosaramba szőlőt
  1 file changed, 1 insertion(+)
 ```
 
@@ -191,9 +191,9 @@ már érdekesebb eredményt láthatunk.
 ```
 $ git log --graph --oneline
 
-* 15719cf (HEAD -> master) Tettem a kosaramba szőlőt
-* 80560db jegyzeteim ignorálása
-* 30bf35d Hoztunk egy hordót
+* c8496bf (HEAD -> master) Tettem a kosaramba szőlőt
+* 996698c jegyzeteim ignorálása
+* 36552bc Hoztunk egy hordót is
 ...
 ```
 
@@ -205,34 +205,35 @@ Hogy lássuk a másik ágat is, tegyük hozzá a `--all` kapcsolót.
 ```
 $ git log --graph --oneline --all
 
-* 15719cf (HEAD -> master) Tettem a kosaramba szőlőt
-| * 7de1c94 (atnevezes) Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
-|/
-* 80560db jegyzeteim ignorálása
-* 30bf35d Hoztunk egy hordót
-...
+* c8496bf (HEAD -> master) Tettem a kosaramba szőlőt
+| * 07ac740 (atnevezes) Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
+|/  
+* 996698c jegyzeteim ignorálása
+* 36552bc Hoztunk egy hordót is
+* a8a9b26 Raktam bele egy körtét
+* 2a685fc Készítettem egy gyümölcskosarat
 ```
 
 Na így már látjuk a másik ágat is.
 Még vizuálisabban jelenleg így állunk:
 
-<div style="text-align:center"><img src="workshop/img/tree_awesome.png" alt="Tree with one branch" /></div>
+<div style="text-align:center"><img src="guide/workshop/img/tree_awesome.png" alt="Tree with one branch" /></div>
 
 Menjünk vissza az `atnevezes` ágra és módosítsunk picit.
 
-```
+```shell-session
 $ git checkout atnevezes
 ```
 
 Majd pedig nevezzük át a `hordo`-t `hordo.txt`-re.
 
-```
+```shell-session
 $ mv hordo hordo.txt
 ```
 
 És ezt is mentsük el
 
-```
+```shell-session
 $ git add .
 $ git commit -m "Adtam kiterjesztést a hordónak"
 ```
@@ -242,17 +243,20 @@ Egy ismételt `git log`-al láthatjuk is a fánkat.
 ```
 $ git log --graph --oneline --all
 
-* 9dcfc79 (HEAD -> atnevezes) Adtam kiterjesztést a hordónak
-* 7de1c94 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
-| * 15719cf (master) Tettem a kosaramba szőlőt
-|/
-* 80560db jegyzeteim ignorálása
+* c040bc1 (HEAD -> atnevezes) Adtam kiterjesztést a hordónak
+* 07ac740 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
+| * c8496bf (master) Tettem a kosaramba szőlőt
+|/  
+* 996698c jegyzeteim ignorálása
+* 36552bc Hoztunk egy hordót is
+* a8a9b26 Raktam bele egy körtét
+* 2a685fc Készítettem egy gyümölcskosarat
 ```
 
 #### Mergelés
 
 Az egyik legfontosabb dolog az ágak létrehozása után, hogy
-betudjuk olvasztani az águnk valahova.
+be tudjuk olvasztani az águnk valahova.
 Az lenne a feladat, hogy a `master`-re beillesszük az
 `atnevezes` ágon végzett módosításaink.  
 Ehhez a `git merge <branch neve>` parancsot használhatjuk.
@@ -261,55 +265,58 @@ megpróbálja beolvasztani oda ahol épp a `HEAD` mutatónk van.
 
 Gyerünk is át a `master` ágra.
 
-```
+```shell-session
 $ git checkout master
 Switched to branch 'master'
 ```
 
 Ezután pedig mergeljük át a `master`-re az `atnevezes` ágat.
 
-```
+```shell-session
 git merge atnevezes
 ```
 
 Ekkor meg fog nyílni a szövegszerkesztőnk, ugyanis egy
-új mentéspontot fogunk készíteni a `master águnkra`.
-A feladott merge üzeneten nem kell módosítanünk, teljesen
+új mentéspontot fogunk készíteni a `master` águnkra.
+A feladott merge üzeneten nem kell módosítanunk, teljesen
 jó úgy.
 
 A merge lefut és láthatjuk mi is történt:
 
 ```
 $ git merge atnevezes
-Removing hordo
 Merge made by the 'recursive' strategy.
- gyumolcskosar => gyumolcskosar.txt | 0
- hordo => hordo.txt                 | 0
- 2 files changed, 0 insertions(+), 0 deletions(-)
+ ") Hozz\303\241adtam a txt kiterjeszt\303\251st a gy\303\274m\303\266lcskosar f\303\241jlhoz" | 248 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ gyumolcskosar => gyumolcskosar.txt |   0
+ hordo => hordo.txt                 |   0
+ 3 files changed, 248 insertions(+)
+ create mode 100644 ") Hozz\303\241adtam a txt kiterjeszt\303\251st a gy\303\274m\303\266lcskosar f\303\241jlhoz"
  rename gyumolcskosar => gyumolcskosar.txt (100%)
- rename hordo => hordo.txt (100%)
+ rename hordo => hordo.tx (100%)
 ```
 
-Most egy újabb `git log`-al ezt láthatjuk:
+Most egy újabb `git log --graph --oneline --all`-al ezt láthatjuk:
 
 ```
-*   366140d (HEAD -> master) Merge branch 'atnevezes'
-|\
-| * 9dcfc79 (atnevezes) Adtam kiterjesztést a hordónak
-| * 7de1c94 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
-* | 15719cf Tettem a kosaramba szőlőt
-|/
-* 80560db jegyzeteim ignorálása
-* 30bf35d Hoztunk egy hordót
+*   e4b5d9d (HEAD -> master) Merge branch 'atnevezes'
+|\  
+| * c040bc1 (atnevezes) Adtam kiterjesztést a hordónak
+| * 07ac740 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
+* | c8496bf Tettem a kosaramba szőlőt
+|/  
+* 996698c jegyzeteim ignorálása
+* 36552bc Hoztunk egy hordót is
+* a8a9b26 Raktam bele egy körtét
+* 2a685fc Készítettem egy gyümölcskosarat
 ```
 
 Ez a bizonyos `merge commit` egyszerre mutat a két ág
 tartalmára.
 
-#### Merge conlict
+#### Merge conflict
 
 Mi van akkor ha ketten egyszerre ugyanazt változtatjuk?  
-Úgy döntöttünk, hogy pálinkát szeretnénk főzni józsival,
+Úgy döntöttünk, hogy pálinkát szeretnénk főzni Rickel,
 szóval a hordóba teszünk ízlés szerint valami
 gyümölcsöt.
 Gyerünk át a saját águnkra, de egy paranccsal.
@@ -317,7 +324,7 @@ Ezt a `-b` kapcsolóval tudjuk
 elérni a `git checkout` mellett.
 
 ```
-$ git checkout -b lacko
+$ git checkout -b blint
 ```
 
 Most egy újabb `git branch` kiadásával már látható, hogy
@@ -325,13 +332,13 @@ Most egy újabb `git branch` kiadásával már látható, hogy
 
 ```
   atnevezes
-* lacko
+* blint
   master
 ```
 
 Tegyünk bele a `hordo.txt`-be egy nekünk tetsző gyümölcsöt.
 
-```gyumolcs.txt
+```
 korte
 ```
 
@@ -342,13 +349,13 @@ Ezt mentsük is el, de most picit csaljunk és ne rakjuk
 $ git commit -a -m "Raktam a hordóba körtét"
 ```
 
-Úgy döntöttünk a szomszéd Józsi, hogy ugyanebbe a hordóba
-körtét szeretne rakni. Menjünk át a master ágra és
+Úgy döntött a szomszéd Rick, hogy ugyanebbe a hordóba
+szilvát szeretne rakni. Menjünk át a master ágra és
 tegyük meg ott.
 
-Azt mondta a szomszéd, hogy szilvát szeretne beletenni, szóval:
-
-```hordo.txt
+Tehát:  
+`hordo.txt`:
+```
 szilva
 ```
 
@@ -364,30 +371,29 @@ hogy mi a helyzet:
 ```
 $ git log --graph --oneline --all
 
-* 41f1c05 (HEAD -> master) Raktam szilvát a hordóba
-| * 6d6d1ac (lacko) Raktam a hordóba körtét
-|/
-*   366140d Merge branch 'atnevezes'
-|\
-| * 9dcfc79 (atnevezes) Adtam kiterjesztést a hordónak
-| * 7de1c94 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
-* | 15719cf Tettem a kosaramba szőlőt
-|/
-* 80560db jegyzeteim ignorálása
-* 30bf35d Hoztunk egy hordót
-...
+* 85744ad (HEAD -> master) Raktam szilvát a hordóba
+*   e4b5d9d (blint) Merge branch 'atnevezes'
+|\  
+| * c040bc1 (atnevezes) Adtam kiterjesztést a hordónak
+| * 07ac740 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz
+* | c8496bf Tettem a kosaramba szőlőt
+|/  
+* 996698c jegyzeteim ignorálása
+* 36552bc Hoztunk egy hordót is
+* a8a9b26 Raktam bele egy körtét
+* 2a685fc Készítettem egy gyümölcskosarat
 ```
 
 Na és akkor most mergeljünk be a master-re a módosításaink.
 
 ```
-$ git merge lacko
+$ git merge blint
 Auto-merging hordo.txt
 CONFLICT (content): Merge conflict in hordo.txt
 Automatic merge failed; fix conflicts and then commit the result.
 ```
 
-Oh! Merge conlict keletkezett.  
+Oh! Merge conflict keletkezett.  
 Nem kell megijedni, nem a világ vége és a git segít ahol tud.
 
 Az a helyzet, hogy egyszerre ugyanazt a sort módosítottuk és a git nem tudta
@@ -395,7 +401,7 @@ eldönteni mit tegyen. Megtartsa az egyiket vagy mindkettőt? Mégis mi legyen?
 
 Ezeket a kérdéseket nekünk kell megválaszolnunk.
 
-Először nézzük meg, mit a státusz.
+Először nézzük meg, mi a státusz.
 
 ```
 $ git status
@@ -422,14 +428,14 @@ Nézzük meg mi van a fájlunkban.
 szilva
 =======
 korte
->>>>>> lacko
+>>>>>> blint
 ```
 
 Mit is jelent ez? Ketté szedte az bejövő adatokat a git arra ahová mergeltünk
-(`HEAD`) és amit mergeltünk (`lacko`). Köztük pedig egy sor "======="-t láthatunk.
+(`HEAD`) és amit mergeltünk (`blint`). Köztük pedig egy sor "======="-t láthatunk.
 Itt már csak átírjuk a fájlt ahogy szeretnénk, hogy kinézzen.
 
-```hordo.txt
+```
 korte
 ```
 
@@ -453,15 +459,16 @@ Továbbra is azt írja, amit az imént. Amíg nem commitoljuk a módosításunk,
 addig ezt is fogja. Hát akkor mentsünk.
 
 ```
-git commit -a -m "lacko branch mergelve és konflikt megoldva"
+git commit -a -m "blint branch mergelve és konflikt megoldva"
 ```
 
 Nézzük meg hogy néz ki a gráfunk ezután.
 
 ```
-*   7341274 (HEAD -> master) lacko branch mergelve és konflikt megoldva
+*   7341274 (HEAD -> master) blint
+ branch mergelve és konflikt megoldva
 |\
-| * 6d6d1ac (lacko) Raktam a hordóba körtét
+| * 6d6d1ac (blint) Raktam a hordóba körtét
 * | 41f1c05 Raktam szilvát a hordóba
 |/
 *   366140d Merge branch 'atnevezes'

index.html

@@ -40,7 +40,7 @@
           },
           {
             title: 'GitSCH',
-            link: 'https://git.sch.bme.hu/rlacko/git-presentation',
+            link: 'https://git.sch.bme.hu/blintmester/git-presentation',
           },
         ],
         sidebar: [
@@ -78,15 +78,6 @@
               },
             ],
           },
-          {
-            title: 'Távoli Repository',
-            children: [
-              {
-                title: 'Alapok és SSH kulcs',
-                link: '/guide/remote/1_basics',
-              },
-            ],
-          },
         ],
         fetchOptions: { cache: 'no-cache' },
       });