Szerkesztő:Madbence/Git tutorial - Laptörténet

Madbence: /* Megjegyzés */

2014-02-09T18:26:37Z

Megjegyzés

← Régebbi változat		A lap 2014. február 9., 20:26-kori változata
224. sor:		224. sor:

	=Megjegyzés=		=Megjegyzés=
	Az írás 2012 elejéről származik, azóta kicsit jobban belemélyedtem a gitbe, de szerintem a leírás még használható. [[Szerkesztő:Madbence\|lennon]] ([[Szerkesztővita:Madbence\|vita]]) 2013. január 20., 02:26 (CET)		Az írás 2012 elejéről származik, azóta kicsit jobban belemélyedtem a gitbe, de szerintem a leírás még használható.
			[[Szerkesztő:Madbence\|lennon]] ([[Szerkesztővita:Madbence\|vita]]) 2013. január 20., 02:26 (CET)

			Egy kicsit kibővítettem, bár még így is elég rövid
			[[Szerkesztő:Madbence\|lennon]]<sup>([[Szerkesztővita:Madbence\|vita]])</sup> 2014. február 9., 18:26 (UTC)

Madbence: Mégkúlabb lett \o/

2014-02-09T18:25:29Z

Mégkúlabb lett \o/

← Régebbi változat		A lap 2014. február 9., 20:25-kori változata
1. sor:		1. sor:
	==Leírás==		==Leírás==
	A Git egy elosztott verziókezelő rendszer, tehát SVN-nel (és társaival) ellentétben nem egy központi szerveren van meg ~~minden fájl~~, hanem ~~mindenhol elérhető a teljes repó~~.		A Git egy elosztott verziókezelő rendszer, tehát SVN-nel (és társaival) ellentétben nem egy központi szerveren van meg az egész version history, hanem (többnyire) lokálisan is megvan az egész repository.
	Rengeteg git parancs van, én csak a legfontosabbakat írom le (minden platformra van GUI is hozzá, nekem ezek nem túl szimpatikusak, sokkal hatékonyabb parancssorból buzgerálni mindent)		Rengeteg git parancs van, én csak a legfontosabbakat írom le (minden platformra van GUI is hozzá, nekem ezek nem túl szimpatikusak, sokkal hatékonyabb parancssorból buzgerálni mindent)

9. sor:		9. sor:
	$ git init</nowiki>		$ git init</nowiki>

	~~Ez annyira~~ nem ~~izgalmas~~, egy létező ~~repót lekérni annál inkább:~~		Ha nem akarunk tökölni az <code>mkdir project; cd project; git init</code> unalmas folyamattal:
			<nowiki>
			$ git init project</nowiki>

			Készen is vagyunk. Jöjjön a másik módszer (a gyakoribb), amikor egy létező repóhoz akarunk hozzáférni. Ezt hívjuk klónozásnak.

	<nowiki>		<nowiki>
	$ git clone https://foo.bar/baz.git</nowiki>		$ git clone https://foo.bar/baz.git</nowiki>

	Ez a parancs az aktuális könyvtárban csinál egy baz mappát, oda pedig mindent szépen letölt.		Ez a parancs az aktuális könyvtárban csinál egy baz mappát, oda pedig mindent szépen letölt. Ha nem tetszik a baz, utolsó paraméterként odabiggyeszthetjük a célkönyvtár nevét (pl .-ot, ha az aktuális könyvtárba szeretnénk létrehozni a repót)

	Kultúráltak vagyunk, úgyhogy konfigoljuk be a gitet:		Kultúráltak vagyunk, úgyhogy konfigoljuk be a gitet:
22. sor:		26. sor:
	$ git config --global user.email gipsz@jakab.com</nowiki>		$ git config --global user.email gipsz@jakab.com</nowiki>

	Aki nem szereti a vim editort, az beállíthajta, mivel szeretné a commitokat szerkeszteni:		Aki nem szereti a vim editort (az bizony meleg!), az beállíthajta, mivel szeretné a commitokat szerkeszteni:

	<nowiki>		<nowiki>
	$ git config --global core.editor emacs</nowiki>		$ git config --global core.editor emacs</nowiki>

	Emacs helyett persze mást is lehet én notepad++-t szoktam használni (ha panaszkodik az elérési útra windowson, akkor az idézőjelekkel kell babrálni:		Emacs helyett persze mást is lehet én windowson notepad++-t szoktam használni (ha panaszkodik az elérési útra windowson, akkor az idézőjelekkel kell babrálni:
	"'C:/npp/npp.exe' -multiInst -nosession")		"'C:/npp/npp.exe' -multiInst -nosession"). De egyébként ne használjunk windowst, nagyon gáz.

	==Hozzáadás==		==Hozzáadás==
69. sor:		73. sor:
	Nem kell mindig egyesével hozzáadni a commithoz a fájlokat, az -a kapcsoló automatikusan minden változást bevesz (az új fájlokat még mindig nekünk kell fölvenni!)		Nem kell mindig egyesével hozzáadni a commithoz a fájlokat, az -a kapcsoló automatikusan minden változást bevesz (az új fájlokat még mindig nekünk kell fölvenni!)
	Ha nem vagyunk biztosak benne, mi kerül a commitba, a --verbose kapcsoló a commit üzenet megadásakor az egész diffet berakja (diff=előző és mostani változat közötti különbség)		Ha nem vagyunk biztosak benne, mi kerül a commitba, a --verbose kapcsoló a commit üzenet megadásakor az egész diffet berakja (diff=előző és mostani változat közötti különbség)

			Villámgyors alias: <code>$ git config --global alias.civ "commit --interactive --verbose"</code>, ezek után a <code>$ git civ</code> egy kényelmes szöveges menüt ad nekünk, ahol kényelmesen összerakhatjuk a kommitot.

	==Elkúrás==		==Elkúrás==
77. sor:		83. sor:

	Az -m kapcsoló használható természetesen.		Az -m kapcsoló használható természetesen.

			Mi van, ha nem az utolsó kommit rossz? Akkor egy kicsit nehezebb dolgod van, de semmi gond: <code>$ git rebase -i xxx</code> ahol xxx a rossz kommit szülője. Kapunk egy editort, ahol szépen fel vannak sorolva a kommitok, ezt lehet bántani, átrendezni, kommitokat egybeolvasztani, stb. Ha kulturáltan akarunk fejleszteni (ilyen elég ritkán fordul elő sajnos), akkor mielőtt feltöltenénk a szerverre a változtatásokat, előtte tegyük rendbe a kommitokat.

	Mi van, ha szar az egész commit? A reset pont jól fog jönni:		Mi van, ha szar az egész commit? A reset pont jól fog jönni:
92. sor:		100. sor:
	$ git reset --mixed HEAD~</nowiki>		$ git reset --mixed HEAD~</nowiki>

	Ez megcsinálja ugyanazt, mint a --soft, de a commithoz hozzáadott fájlokat (hívjuk indexnek ezután) is visszaállítja a mutatott commitra. Ha nem adunk meg a resetnek semmilyen kapcsolót, akkor ezt csinálja alapból.		Ez megcsinálja ugyanazt, mint a --soft, de a commithoz hozzáadott fájlokat (hívjuk indexnek ezután, mert ez a neve) is visszaállítja a mutatott commitra. Ha nem adunk meg a resetnek semmilyen kapcsolót, akkor ezt csinálja alapból.

	Még félelmetesebb a		Még félelmetesebb a
111. sor:		119. sor:
	<nowiki>		<nowiki>
	$ git checkout feature</nowiki>		$ git checkout feature</nowiki>

			Vagy a kettő egyben:

			<nowiki>
			$ git checkout -b feature</nowiki>

	Ezzel elhagyjuk az eredeti fejlesztési ágat (alapból a fő ág a "master"), és átlépünk a "feature" ágra. Itt commitolhatunk kedvünkre, satöbbi. Sőt, még további ágakat is létrehozhatunk.		Ezzel elhagyjuk az eredeti fejlesztési ágat (alapból a fő ág a "master"), és átlépünk a "feature" ágra. Itt commitolhatunk kedvünkre, satöbbi. Sőt, még további ágakat is létrehozhatunk.
120. sor:		133. sor:
	$ git checkout master		$ git checkout master
	$ git merge feature		$ git merge feature
	$ git branch -D feature</nowiki>		$ git branch -d feature</nowiki>

	Először visszaváltunk a főágra. Aztán összeolvasztjuk a két ágat. Majd töröljük a feature ágat.		Először visszaváltunk a főágra. Aztán összeolvasztjuk a két ágat. Majd töröljük a feature ágat.
130. sor:		143. sor:

	==Remote==		==Remote==
	Távoli repóba is jó, ha mentünk, ilyeneket tud a github vagy a bitbucket.		Távoli repóba is jó ha mentünk, ilyeneket tud a github vagy a bitbucket (előbbi a preferált, illetve a menő).

	Ha esetleg nem klónoztuk volna a repót, hanem initet használtunk, akkor hozzá kell adni a távoli repót a remote paranccsal:		Ha esetleg nem klónoztuk volna a repót, hanem initet használtunk, akkor hozzá kell adni a távoli repót a remote paranccsal:
149. sor:		162. sor:

	<nowiki>		<nowiki>
	$ git push</nowiki>		$ git push -u origin branch</nowiki>

	~~Nagyon sok szót nem is pazarolnék~~ rá.		Ahol origin a remote neve, branch az ág (pl master). Ez összeköti a lokális és távoli brancheket, szóval ezek után már később elég egy sima <code>$ git push</code>.

			Ha esetleg lesz rá időm, majd írok a githubos pull-request alapú workflow-ról, elég kúl cucc.

	==Hogy is volt?==		==Hogy is volt?==
193. sor:		208. sor:
	* 37b0e0f feature4		* 37b0e0f feature4
	* 662833a feature3</nowiki>		* 662833a feature3</nowiki>

			Mágikus, a fentihez hasonló nagyon trendi <code>$ git lg</code> alias:

			<nowiki>
			$ git config --global alias.lg "log --graph --date-order --all --pretty='%C(yellow)%h%Creset -%C(red)%d%Creset %s %Cgreen(a: %ar, c: %cr) %C(bold blue)<%an>%Creset'"</nowiki>

	Utoljára maradt a blame, ami sorran lebontva jeleníti meg egy fájl utolsó szerkesztőit:		Utoljára maradt a blame, ami sorran lebontva jeleníti meg egy fájl utolsó szerkesztőit:
200. sor:		220. sor:

	Hasznos, ha tudni akarjuk ki kúrta el a fájlt :)		Hasznos, ha tudni akarjuk ki kúrta el a fájlt :)

			Bisect, stb egy kicsit ödvenszebb téma, érdemes elolvasni a git könyvet: http://git-scm.com/book

	=Megjegyzés=		=Megjegyzés=
	Az írás 2012 elejéről származik, azóta kicsit jobban belemélyedtem a gitbe, de szerintem a leírás még használható. [[Szerkesztő:Madbence\|lennon]] ([[Szerkesztővita:Madbence\|vita]]) 2013. január 20., 02:26 (CET)		Az írás 2012 elejéről származik, azóta kicsit jobban belemélyedtem a gitbe, de szerintem a leírás még használható. [[Szerkesztő:Madbence\|lennon]] ([[Szerkesztővita:Madbence\|vita]]) 2013. január 20., 02:26 (CET)

Madbence: Új oldal, tartalma: „==Leírás== A Git egy elosztott verziókezelő rendszer, tehát SVN-nel (és társaival) ellentétben nem egy központi szerveren van meg minden fájl, hanem mindenhol…”

2013-01-20T01:26:36Z

Új oldal, tartalma: „==Leírás== A Git egy elosztott verziókezelő rendszer, tehát SVN-nel (és társaival) ellentétben nem egy központi szerveren van meg minden fájl, hanem mindenhol…”

Új lap

==Leírás==
A Git egy elosztott verziókezelő rendszer, tehát SVN-nel (és társaival) ellentétben nem egy központi szerveren van meg minden fájl, hanem mindenhol elérhető a teljes repó.
Rengeteg git parancs van, én csak a legfontosabbakat írom le (minden platformra van GUI is hozzá, nekem ezek nem túl szimpatikusak, sokkal hatékonyabb parancssorból buzgerálni mindent)

==Kezdés==
Üres repó létrehozása:

<nowiki>
$ git init</nowiki>

Ez annyira nem izgalmas, egy létező repót lekérni annál inkább:

<nowiki>
$ git clone https://foo.bar/baz.git</nowiki>

Ez a parancs az aktuális könyvtárban csinál egy baz mappát, oda pedig mindent szépen letölt.

Kultúráltak vagyunk, úgyhogy konfigoljuk be a gitet:

<nowiki>
$ git config --global user.name "Gipsz Jakab"
$ git config --global user.email gipsz@jakab.com</nowiki>

Aki nem szereti a vim editort, az beállíthajta, mivel szeretné a commitokat szerkeszteni:

<nowiki>
$ git config --global core.editor emacs</nowiki>

Emacs helyett persze mást is lehet én notepad++-t szoktam használni (ha panaszkodik az elérési útra windowson, akkor az idézőjelekkel kell babrálni:
"'C:/npp/npp.exe' -multiInst -nosession")

==Hozzáadás==
Ha csinálunk egy új fájlt/mappát, az alapból nem lesz verziókezelve, ez meg is nézhetjük a status parancs segítségével:

<nowiki>
$ touch README
$ git status
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# README
nothing added to commit but untracked files present (use "git add" to track)</nowiki>

A git le is lövi a poént, az add parancs fájlokat/mappákat ad hozzá a következő commithoz (akárhányat)

<nowiki>
$ git add README</nowiki>

Mostmár a rendszer látja a fájlt, de még nincs benne a repóban, committolni kell.

<nowiki>
$ git status
# Changes to be committed:
# (use "git rm --cached <file>..." to unstage)
#
# new file: README</nowiki>

Ezt a commit parancs el is végzi nekünk...

<nowiki>
$ git commit</nowiki>

Nagyon fontos dolgunk van, mégpedig írni egy commit üzenetet. Fontos, hogy világos, érthető legyen, később is lehessen tudni, miért történt az a változtatás.
Ha nem tetszik az alap szövegszerkesztő, akkor be tudunk állítani sajátot, vagy rögtön a parancs mellet az -m kapcsolóval meg is írhatjuk az üzenetet.

<nowiki>
$ git commit -m "Initial commit"</nowiki>

Nem kell mindig egyesével hozzáadni a commithoz a fájlokat, az -a kapcsoló automatikusan minden változást bevesz (az új fájlokat még mindig nekünk kell fölvenni!)
Ha nem vagyunk biztosak benne, mi kerül a commitba, a --verbose kapcsoló a commit üzenet megadásakor az egész diffet berakja (diff=előző és mostani változat közötti különbség)

==Elkúrás==
Mi van, ha elkúrtam az üzenetet, és már commitoltam? Semmi gond, lehet szerkeszteni:

<nowiki>
$ git commit --amend</nowiki>

Az -m kapcsoló használható természetesen.

Mi van, ha szar az egész commit? A reset pont jól fog jönni:

<nowiki>
$ git reset --soft HEAD~</nowiki>

Kis magyarázat. A commitok jönnek szép sorban, az utolsó commit az ágon a HEAD, a ~ jel a HEAD szülője lesz (~2 nagyszülő, satöbbi)

A --soft kapcsoló pedig azt fogja csinálni, hogy csak a HEAD mutatót helyezi át. Nem fog fájlokat módosítani, nem bántja a fájlokat, amiket hozzáadtunk a commithoz (add)

Kicsit drasztikusabb változat:

<nowiki>
$ git reset --mixed HEAD~</nowiki>

Ez megcsinálja ugyanazt, mint a --soft, de a commithoz hozzáadott fájlokat (hívjuk indexnek ezután) is visszaállítja a mutatott commitra. Ha nem adunk meg a resetnek semmilyen kapcsolót, akkor ezt csinálja alapból.

Még félelmetesebb a

<nowiki>
$ git reset --hard HEAD~</nowiki>

Ez mindent visszaállít, ténylegesen a fájlokat is! Szóval csak óvatosan.

==Fejlesztési ágak==
Eddig a commitok szép sorban jöttek egymás után, viszont nagyobb projecteknél ez nem igazán jó ötlet, célszerű a fejlesztést ágakra lebontani. Erre van megoldás a gitben:

<nowiki>
$ git branch feature</nowiki>

A "feature" az ág neve, amit létrehozunk. A gyökere az aktuális commit. De még nem használjuk, szóval ezt is meg kell mondani:

<nowiki>
$ git checkout feature</nowiki>

Ezzel elhagyjuk az eredeti fejlesztési ágat (alapból a fő ág a "master"), és átlépünk a "feature" ágra. Itt commitolhatunk kedvünkre, satöbbi. Sőt, még további ágakat is létrehozhatunk.
Ha egy kicsit elvesztünk, hogy most milyen ágon is vagyunk, akkor simán a git branch megmondja egyrészt milyen ágaink vannak, másrészt megmondja melyiken is vagyunk (csillag van a neve előtt)

Ha kész a fícsör lefejlesztése, szeretnénk visszavezetni a főágba a változásokat. Erre lesz jó a félelmetes merge:

<nowiki>
$ git checkout master
$ git merge feature
$ git branch -D feature</nowiki>

Először visszaváltunk a főágra. Aztán összeolvasztjuk a két ágat. Majd töröljük a feature ágat.
Sajnos irtkán ilyen szép az élet, néha a git nem tudja magától megmondani, hogy mit honnan szedjen, többen szerkesztették ugyanazt a fájlt. Ilyenkor conflict van.
Ezeket manuálisan kézzel kell kijavítani, elmenteni a fájlokat, majd commitolni manuálisan (a merge ugyanis egy commit).

Ha nagy mázlink van, és a master ágon senki sem fejlesztett, amíg mi a branchon bűvészkedtünk, akkor a merge helyett fast-forward történik, a head egyszerűen előreugrik (képzeljétek el az ágakat, mint függőleges vonalak, a commitok bogyók, elég jól lehet látni, miért is lehet ezt megtenni).
Szóval ennek örülünk :)

==Remote==
Távoli repóba is jó, ha mentünk, ilyeneket tud a github vagy a bitbucket.

Ha esetleg nem klónoztuk volna a repót, hanem initet használtunk, akkor hozzá kell adni a távoli repót a remote paranccsal:

<nowiki>
$ git remote add origin https://foo.bar/baz.git</nowiki>

Az add hozzáad, az origin a neve, így fogjuk hívni ezután. Tiszta sor.

Le szeretnénk kérni a repó aktuális változatát:

<nowiki>
$ git fetch</nowiki>

Ha több távoli repónk is van, akkor oda lehet írni a nevét is (alapból origin-nak hívják)

Ha szeretnénk az eddigi commitokat fenyomni a szerverre:

<nowiki>
$ git push</nowiki>

Nagyon sok szót nem is pazarolnék rá.

==Hogy is volt?==
Már mindent tudunk a gitről, csak azt nem, hogy hogyan is tudjuk visszanézni, mit csináltunk. Ezt többnyire a log parancs tudja szépen megmutatni:

<nowiki>
$ git log</nowiki>

Kb mindent ki lehet vele deríteni, az -n kapcsoló a bejegyzések számát limitálja, a --since="2 weeks ago" az utolsó két hét commitjait mutatja, ha egy fájlnevet adunk meg a végén, akkor csak a rá vonatkozó commitok jelennek meg (ugyanez mappanév/ változattal mappára), az -S'foo()' azokat a commitokat jeleníti meg, amiben benne volt (eltűnt/megjelent) a foo(), --stat megmutatja mennyi sor változott.

Formázni is lehet, a --pretty=online pl egysoros változatban nyomja ki.

Kismillió kapcsolója van, itt meg lehet találni mindet: http://linux.die.net/man/1/git-log

A --graph grafikusan is megjeleníti a fejlesztési ágakat. Itt egy példa:

<nowiki>
$ git log --graph --oneline --date-order
* b450119 partial
* 39d69f0 Merge branch 'exp'
|\
* \ 2bf5367 Merge branch 'exp2'
|\ \
* | | ab5a665 6
| * | 369d10b fb2
| * | 6db3ec6 fb1
| | * 0d726e6 fa4
| | * 5064725 fa3
| |/
| * 542c972 fa2
| * ad88635 fa1
|/
* d14df30 5
* be70310 4
* 21bb204 Merge branch 'feature'
|\
* | b911d4f third
| * 5e6acf2 feature6
| * 577f064 feature5
|/
* 37b0e0f feature4
* 662833a feature3</nowiki>

Utoljára maradt a blame, ami sorran lebontva jeleníti meg egy fájl utolsó szerkesztőit:

<nowiki>
$ git blame file</nowiki>

Hasznos, ha tudni akarjuk ki kúrta el a fájlt :)

=Megjegyzés=
Az írás 2012 elejéről származik, azóta kicsit jobban belemélyedtem a gitbe, de szerintem a leírás még használható. [[Szerkesztő:Madbence|lennon]] ([[Szerkesztővita:Madbence|vita]]) 2013. január 20., 02:26 (CET)