reset repo

2026-05-13 17:21:50 +00:00 · 2025-01-03 22:30:04 +01:00
commit b166a1d130
314 changed files with 31890 additions and 0 deletions
@@ -0,0 +1,46 @@
+# Dodatne informacije
+
+Predvidevamo da ste že končali osnovni vodič. Sedaj boste dobili dodatne informacije o napredni uporabi Git-a.
+
+### [Popravljanje commita](amending-a-commit.sl.md)
+Informacije o tem kako spremeniti commit v oddaljenem repositoryu.
+> Uporabi, ko moraš spremeniti že narejeni commit.
+
+### [Nastavljanje Git-a](configuring-git.sl.md)
+Informacije o tem kako nastaviti uporabnika in druge možnosti v Git-u.
+> Uporabi za boljši nadzor nad svojo Git konfiguracijo.
+
+### [Kako imeti svojo različico sinhronizirano z oddaljenim repository-em](keeping-your-fork-synced-with-this-repository.sl.md)
+Informacije o tem kako obdržati svojo različico v skladu z glavnim repository-em. To je pomembno, ker lahko veliko ljudi prispeva k projektu.
+> Sledi tem korakom, če tvoja verzija nima nobenih sprememb v nadrejenem imeniku (parent directory).
+
+### [Premikanje commita v drugo vejo](moving-a-commit-to-a-different-branch.sl.md)
+Informacije o tem kako premakniti commit v drugo vejo.
+> Sledi tem korakom in premakni commit v drugo vejo.
+
+### [Odstranjevanje datoteke](removing-a-file.sl.md)
+Informacije o tem kako odstraniti datoteko z svojega lokalnega repository-ja.
+> Sledi tem korakom in odstrani datoteko pred commitom.
+
+### [Odstrani vejo s svojega repository-ja](removing-branch-from-your-repository.sl.md)
+Informacije o tem kako zbrisati vejo s svojega repository-ja.
+> Sledi tem korakom šele potem, ko je bil tvoj pull-request že združen.
+
+### [Razreševanje sporov pri združevanju](resolving-merge-conflicts.sl.md)
+Informacije o tem kako razrešiti spore pri združevanju (resolve merge conflicts).
+> Sledi tem korakom pri razreševanju nadležnih sporov pri združevanju.
+
+### [Povrnitev commita](reverting-a-commit.sl.md)
+Informacije o tem kako povrniti commit na oddaljenem repository-ju v prejšnje stanje. Zelo uporabno, če moraš razveljaviti commit, ki je bil že poslan na GitHub.
+> sledi tem korakom, če želiš povrniti commit v prejšnje stanje.
+
+### [Stiskanje commit-ov](squashing-commits.sl.md)
+Informacije o tem kako stisnite commite z interaktivnim rebase-om.
+> Uporabi te korake, če želiš narediti pull-request v odprto-kodni projekt in te pregledovalec prosi, da stisni (squash) vse commite v enega in dodaj informativno commit sporočilo.
+
+### [Razveljavljanje lokalnega commita](undoing-a-commit.sl.md)
+Informacije o tem kako razveljaviti commit v svojem localnem repository-ju. Uporabno, ko si naredil zmešnjavo v lokalnem repository-ju in ga želiš postaviti na prejšnje stanje.
+> Sledi korakom, ko želiš razveljaviti lokalni commit.
+
+### [Uporabne povezave](../git_workflow_scenarios/Useful-links-for-further-learning.md)
+Ta dokument je namenjem vsem blogom, uporabnim stranem, spletnim stranem s triki in namigi, ki naredijo naša življenja lažja. Stran naj bi bila kazalo teh uporabnih povezav, ki lahko pomagajo vsem novincem v odprto-kodnem svetu in vsem, ki imajo željo po dodatnem znanju.
@@ -0,0 +1,48 @@
+# Popravljanje Commita
+
+Kaj narediti, če pošlješ commit v oddaljeni repository in potem ugotoviš da si se zatipkal ali pa pozabil dodati vrstico kode v svoj zadnji commit.
+Kako to popraviti? O tem govori ta vodič.
+
+## Spreminjanje komentarja commit-a, ki je bil pred kratkim poslan na GitHub
+To lahko naredimo brez da bi odprli datoteko:
+*   V terminal vpiši ```git commit --amend -m "followed by your new commit message"```
+*   Zaženi ```git push origin <branch-name>``` da pošlješ commit s spremembo v repository.
+
+Opomba: Če vtipkaš samo ```git commit --amend```, se odpre tvoj urejevalnik besedil in te pozove da spremeniš komentar commit-a.
+Zastavica ``-m`` to prepreči.
+
+## Sprememba enega commit-a
+
+No, kaj storiti, če pozabimo narediti eno malo spremembo v datoteki, kot na primer spremeniti eno besedo, vendar smo že poslali commit v oddaljeni repository?
+
+Prikaz praktičnega primera (zgodovina commit-ov tega repository-a):
+```
+g56123f create file botfile
+a2235d updated contributor.md
+a5da0d modified botfile
+```
+Recimo da smo pozabili dodati eno samo besedo datoteki botfile.
+
+Obstajata dva načina kako se stvari lotiti. Prvi primer je da naredimo nov commit, ki vsebuje spremembo:
+```
+g56123f create file botfile
+a2235d updated contributor.md
+a5da0d modified botfile
+b0ca8f added single word to botfile
+```
+Drugi način je, da spremenimo commit a5da0d, mu dodamo pozabljeno besedo in ga pošljemo v GitHub, vse skupaj kot en commit.
+Drugi način nam je bolj všeč, ker imamo opravka z manjšo spremembo.
+
+Da to dosežemo, storimo naslednje:
+*   Spremenimo datoteko. V tem primeru bomo spremenili datoteko botfile in ji dodali spuščeno besedo.
+*   Nato bomo dodali datoteko v čakalnico z ```git add <filename>```.
+
+Običajno ko dodamo datoteke v čakalnico, je naslednji korak, da naredimo commit s komentarjem ( git commit -m "our commit message" ).
+V tem primeru pa želimo popraviti že narejen commit, zato namesto tega izvedemo:
+
+* ```git commit --amend```
+ Ukaz nam v tem primeru prikaže urejevalnik besedila in nam omogoči da spremenimo komentar. Sami se odločimo, ali spremenimo komentar, ali pustimo prejšnjega.
+* Zapustimo urejevalnik besedil.
+* Pošljemo spremembe z `` `git push origin <branch-name>` ``.
+
+Na ta način bosta obe spremembi združeni v enem commit-u.
@@ -0,0 +1,77 @@
+# Nastavljanje Git okolja
+
+Ko si prvič poskusil narediti commit z Git-om, je možno da se je prikazalo naslednje sporočilo:
+
+```bash
+$ git commit
+*** Please tell me who you are.
+
+Run
+
+git config --global user.email "you@example.com"
+git config --global user.name "Your Name"
+
+to set your account's default identity.
+Omit --global to set the identity only in this repository.
+```
+
+Git mora vedeti kdo si, da lahko ustvari commit. Ko delaš v skupini z več ljudmi, naj bi se vedno vedelo kdo je naredil katero spremembo v projektu in kdaj jo je nardil. V ta namen je bil Git ustvarjen tako, da so commit-i vezani na ime in e-pošto.
+
+Obstaja več načinov kako ukazu `git commit` podati svoje ime in e-pošto in nekaj jih bomo pregledali v naslednjih vrsticah.
+
+### Globalna konfiguracija
+
+Ko nekaj shranimo v globalno konfiguracijo (global config), je ta nastavitev dosegljiva vsem repository-em na katerih delaš. Ta način se priporoča in deluje v večini primerov.
+
+Da nekaj shranimo v globalno konfiguracijo, uporabimo ukaz `config`:
+
+`$ git config --global <variable name> <value>`
+
+V primeru uporabniških podatkov:
+
+```
+$ git config --global user.email "you@example.com"
+$ git config --global user.name "Your Name"
+```
+
+### Konfiguracija repository-ja
+
+Kot nam že samo ime pove, so te konfiguracije omejene samo na en repository. Če želiš narediti commit v točno določen repository, recimo službeni projekt, s svojo službeno e-pošto, potem uporabimo to metodo.
+
+Da nekaj shranimo v konfiguracijo repository-ja, uporabimo ukaz `config` in spustimo zastavico `--global`:
+
+
+`$ git config <variable name> <value>`
+
+V primeru uporabniških podatkov:
+
+```
+$ git config user.email "you@alternate.com"
+$ git config user.name "Your Name"
+```
+
+### Konfiguracija ukazne vrstice
+
+Te konfiguracije so omejene samo na trenutno ukazno vrstico. Vsi Git ukazi sprejmejo predpono `-c` pred glagolom ukaza. S tem ustvarimo začasno konfiguracijo.
+
+Da nekaj shranimo v konfiguracijo ukazne vrstice:
+
+`$ git -c <variable-1>=<value> -c <variable-2>=<value> <command>`
+
+V našem primeru bi ukaz commit uporabili takole:
+
+`git -c user.name='Your Name' -c user.email='you@example.com' commit -m "Your commit message"`
+
+### O prednosti
+
+Zaporedje uporabe med zgoraj omenjenimi metodami je sledeče `command-line > repository > global`. To pomeni da, če je spremenljivka shranjena v ukazni vrstici in globalno, bi bila uporabljena vrednost v konfiguraciji ukazne vrstice.
+
+## Dodatno
+
+Do sedaj smo delali samo z nastavitvami uporabnika, vendar obstaja še nekaj drugih konfiguracij. Nekatere med njimi so: 
+
+1.  `core.editor` - za določitev urejevalnika besedila, ki se uporabi za pisanje komentarjev, itd.
+2.  `commit.template` - za določitev datoteke v sistemu, ki se uporabi kot začetna predloga za commit 
+3.  `color.ui` - za določitev boolean vrednosti za uporabo barv v Git-ovem izpisu.
+
+Nekaj podrobnosti smo poenostavili za lažje razumevanje. Več si lahko prebereš na [git-scm.com](https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration).
@@ -0,0 +1,40 @@
+# Kako imeti svojo različico sinhronizirano z oddaljenim repository-em
+
+Najprej moramo razumeti kako poteka sinhronizacija. V tej shemi so trije različni repository-ji: moj javni repository na GitHub-u `github.com/Roshanjossey/first-contributions/`, tvoja različica tega repository-ja na GitHub-u `github.com/Your-Name/first-contributions/` in lokalni repository na tvojem računalniku. Ta način delovanja je značilen za odprto-kodne projekte in se imenuje `Triangle Workflow`.
+
+<img style="float;" src="https://firstcontributions.github.io/assets/additional-material/triangle_workflow.png" alt="triangle workflow" />
+
+Da obdržimo tvoja dva repository-ja sinhronizirana z mojim javnim repository-jem, moramo najprej pridobiti javni repository in ga združiti s tvojim lokalnim repository-jem ( fetch and merge ).
+Naslednji korak bo, da pošljemo tvoj lokalni repository v tvojo GitHub različico. Kot smo že prej videli, lahko samo iz GitHub različice zahtevamo "pull request". Zato je tvoja GitHub različica zadnji repository, ki se ga posodobi na zadnjo verzijo.
+
+No pa poglejmo kako se to naredi:
+
+Najprej moraš biti v svoji glavni veji ( master branch ). Da izveš na kateri veji si trenutno, izvedi ta ukaz in poglej prvo vrstico odgovora:
+```
+git status
+```
+Če nisi na glavni veji uporabi:
+```
+git checkout master
+```
+
+Potem dodaš moj javni repository svojemu git-u z ukazom `add upstream remote-url`:
+```
+git remote add upstream https://github.com/Roshanjossey/first-contributions
+```
+Na ta način povemo git-u da obstaja še ena verzija tega projekta na podanem naslovu in da jo imenujemo `upstream`. Sedaj, ko ima tvoj git ime in naslov, lahko s tega naslova pridobimo zadnjo verzijo javnega repository-ja z ukazom `fetch`:
+```
+git fetch upstream
+```
+
+Pravkar ste pridobili zadnjo verzijo moje različice (`upstream` remote). Sedaj pa je potrebno še združiti javni repository v tvojo glavno vejo (master branch).
+```
+git rebase upstream/master
+```
+Tukaj združuješ javni repository s svojo glavno vejo. Glavna veja na tvojem računalniku je sedaj posodobljena. Na koncu pošlješ še svojo glavno vejo v tvojo različico (fork) na GitHub-u in tudi ta bo posodobljena z zadnjimi spremembami:
+```
+git push origin master
+```
+Tukaj lahko vidiš da pošiljaš v oddaljeni repository imenovan `origin`.
+
+Na tej točki, so vsi tvoji repository-ji posodobljeni. Dobro opravljeno! To stori vsakič, ko te tvoj GitHub repository opozori, da ni sinhroniziran z ostalimi repository-ji.
@@ -0,0 +1,24 @@
+# Premikanje commita v drugo vejo
+Kaj storiti, če izvedeš commit svojih sprememb, in potem ugotoviš da si izvedel commit v napačni veji? Kako lahko to spremenimo? To je razloženo v tem vodiču.
+
+## Premikanje zadnjega commita v obstoječo vejo
+To storiš z naslednjimi ukazi:
+
+```git reset HEAD~ --soft``` - Razveljavi zadnji commit, spremembe ostanejo na voljo.  
+```git stash``` - Posname stanje direktorija in ga shrani v `stash`.  
+
+```git checkout name-of-the-correct-branch``` - Prestavi v drugo vejo.
+```git stash pop``` - Vzame zadno shranjeno stanje iz `stash-a`.  
+```git add .``` - Ali dodaš posamezne datoteke.  
+```git commit -m "your message here"``` - Shrani in izvede commit sprememb.  
+
+Sedaj so tvoje spremembe na pravi veji.
+
+
+### Premikanje zadnjih nekaj commitov v novo vejo
+To storiš z naslednjimi ukazi:
+```git branch newbranch``` -  Ustvariš novo vejo. Nova veja ima vse prej ustvarjene commite.
+```git reset --hard HEAD~#``` - Premakni glavno vejo ( master ) nazaj za # commit-ov. Ti commit-i bodo izbrisani z glavne veje!
+```git checkout newbranch``` - Prestaviš se v novo vejo, ki ima vse prej ustvarjene commit-e. 
+
+Pomembno: Vse spremembe, ki niso bile commit-ane, bodo IZGUBLJENE!
@@ -0,0 +1,23 @@
+# Odstranjevanje datoteke
+
+Včasih si želiš odstraniti datoteko z Git-a, vendar je ne želiš odstraniti s svojega računalnika. To lahko storiš z uporabo naslednjega ukaza: 
+
+``git rm <file> --cached``
+
+## Kaj se je zgodilo?
+
+Git ne bo več sledil spremembam v odstranjeni datoteki. Kar se tiče Git-a, ta datoteka ne obstaja več. Če poiščeš datoteko na svojem disku, vidiš da še vedno obstaja.
+
+V zgornjem primeru smo uporabili zastavico `--cached`. Če je ne bi uporabili, bi Git odstranil datoteko tudi z našega diska.
+
+Če sedaj ustvarimo commit z `git commit -m "Remove file1.js"` in ga pošljemo v oddaljeni repository z ukazom `git push origin master`, bo datoteka odstranjena tudi iz oddaljenega repository-ja.
+
+## Dodatne možnosti
+
+-   Če želiš odstraniti več datotek, jih lahko vse vljučiš v en ukaz:
+
+    `git rm file1.js file2.js file3.js --cached`
+
+-   Lahko uporabiš nadomestni znak (*) da odstraniš podobne datoteke. Na primer, če želiš odstraniti vse datoteke s končnico .txt s svojega repository-ja, uporabi ukaz:
+
+    `git rm *.txt --cached`
@@ -0,0 +1,30 @@
+# Odstrani vejo s svojega repository-ja
+
+Če si sledil vodiču do tukaj, sedaj tvoja veja `<add-your-name>` ni več uporabna in jo lahko zbrišeš z lokalnega repository-ja. To ni nujno potrebno, vendar ime te veje kaže njen namen obstoja. Ker je opravila svoje delo, jo lahko zbrišeš.
+
+Najprej združiš `<add-your-name>` z glavno ( master ) vejo, zato se postavi vanjo:
+```
+git checkout master
+```
+
+Združi `<add-your-name>` z master:
+```
+git merge <add-your-name> master
+```
+
+Odstrani `<add-your-name>` z lokalnega repository-ja:
+```
+git branch -d <add-your-name>
+```
+
+Sedaj si zbrisal `<add-your-name>` vejo s svojega računalnika in vse zgleda urejeno. Vendar ta veja še vedno obstaja v tvoji GitHub različici ( fork ). Preden jo zbrišeš tudi tam, vedi da moraš najprej poslati "Pull request" mojemu repository-ju. Tako da, če je še nisem združil v moj repository, te veje na GitHub-u še ne zbriši!
+
+Če pa je tvoja GitHub veja že združena v moj projekt, in jo želiš zbrisati, uporabi naslednji ukaz:
+```
+git push origin --delete <add-your-name>
+```
+
+Sedaj veš kako počistiti neuporabne veje s svojega repository-ja.
+S časom bo veliko commit-ov dodanih v moj javni repository, in glavni veji na tvojem računalniku in GitHub različici ne bosta več posodobljeni na zadnjo verzijo. Da bodo vsi tvoji repository-ji sinhronizirani z mojim, sledi korakom v tem vodiču:
+
+#### [Kako imeti svojo različico sinhronizirano z oddaljenim repository-em](keeping-your-fork-synced-with-this-repository.sl.md)
@@ -0,0 +1,34 @@
+# Kaj je spor pri združevanju?
+
+Ko poskusiš združiti drugo vejo v vejo v kateri trenutno delaš, vzameš spremembe iz drugega konteksta in jih združiš z datotekami s katerimi trenutno delaš.
+Če dve osebi spremenita vrstico v isti datoteki, ali če se ena oseba odloči zbrisati datoteko medtem, ko se jo druga odloči spremeniti, Git ne ve več kaj je pravilno. Git bo označil datoteko kot spor. Spor, ki ga moraš razrešiti preden lahko nadaljuješ z delom.
+
+# Kako razrešiti spor pri združevanje?
+
+Ko Git zazna spor pri združevanju, bo mesto problema v datoteku označil tako, da ga bo obdal z:
+“<<<<<<<< HEAD” and “>>>>>>>>>>[other branch name]”
+
+Vsebina za prvo oznako bo izhajala iz tvoje trenutne veje. Nato sledi vrstica z "=======", tej pa sledi vsebina iz veje, ki je v nazkrižju s tvojo. Za tem pridejo znaki ">>>>>" in ime te druge veje.
+Naša naloga je da uredimo te vrstice. Ko smo končali, naj bi datoteka izgledala točno tako, kot hočemo da izgleda. Lahko da se bo potrebno posvetovati s sodelavcem, ki je napisal vsebino, ki je v navzkrižju z našo, da se bomo lahko odločili katera koda je prava. Mogoče bo tvoja, mogoče bo njegova - ali pa mešanica obeh.
+
+Primer:
+```
+ <<<<<<< HEAD:mergetest
+ This is my third line
+ =======
+ This is a fourth line I am adding
+ >>>>>>> 4e2b407f501b68f8588aa645acafffa0224b9b78:mergetest
+```
+
+`<<<<<<<`: Nakazuje začetek vrstic, kjer je spor. Te vrstice so iz tvoje datoteke, ki si jo poskusil združiti.
+`=======`: Nakazuje prelomno točko za primerjavo. Razdeli spremembe iz tvojega commit-a (zgoraj) in spremembe nekoga drugega (spodaj) za lažjo predstavo.
+`>>>>>>>`: Nakazuje konec vrstic, kjer je spor.
+
+Spor razrešiš z urejanjem datoteke in ročnim združevanjem delov datoteke, kjer je Git naletel na problem. To lahko pomeni da je potrebno zavreči tvoje spremembe, spremembe nekoga drugega ali pa ustvariti mešanico obeh. Prav tako je potrebno zbrisati '<<<<<<<', '=======', in '>>>>>>>'.
+
+Ko je bil spor razrešen, uporabi ukaz `git add`. Ne pozabi izvesti teste, s katerimi se prepričaš da je bil spor pravilno razrešen.
+
+Lahko si tudi namestiš različne plugine, ki so odvisni od tvojega IDE-ja, za lažje reševanje sporov.
+
+# Kako razveljaviti združitev ( merge )?
+Če želiš razveljaviti združitev uporabi ukaz `git merge —abort`.
@@ -0,0 +1,38 @@
+# Povrnitev commit-a
+
+Povrnitev commit-a pomeni, da ustvarimo nov commit, ki odstrani vse spremembe, ki smo jih napravili v prejšnjem commit-u. Kot da bi naredili ```CTRL + Z ``` v Git-u.
+
+Povrnitev v Git-u je sorazmerno enostavna, ker je vsak commit, ki ga pošljemo v oddaljen repository, povezan s svojim unikatnim alfanumeričnim SHA (Secure Hash Algorithm) ključem.
+To pomeni da lahko povrnemu vsak commit, če le imamo njegov SHA.
+V vsakem primeru pa moramo biti previdni pri povračanju, ker si lahko poškodujemo repository.
+
+Da lahko izberemo SHA točno določenega commit-a, ki ga hočemo odstraniti, nam zelo prav pride seznam vseh commit-ov, ki smo jih napravili.
+Ta seznam dobimo s tem ukazom:
+```git log --oneline ```
+Ukaz ```git log``` bi nam prav tako vrnil SHA, vendar v daljši obliki izpisa. 
+Uporaba zastavice ```--oneline ``` Git-u pove da hočemo pregleden izpis v eni vrstici.
+
+Prvih 7 znakov v vsaki vrstici izpisa se imenuje skrajšani hash commit-a.
+
+Za primer, to je izpis ```git log --oneline ``` za ta repository:
+```
+389004d added spacing in title
+c1b9fc1 Merge branch 'master' into tutorials
+77eaafd added tutorial for reverting a commit
+```
+
+To nam torej pokaže, da lahko z ```git log --oneline```, pridobimo seznam vseh commit-ov narejenih v repository-ju s prvimi 7 znaki njihovih SHA.
+
+No, sedaj lahko poskusimo zbrisati commit "added spacing in title" z naslednjimi koraki:
+
+*   Kopiraj SHA commit-a, v tem primeru ```389004d```
+*   Potem uporabi ukaz ```git revert 389004d```
+
+Sedaj se zažene naš urejevalnik besedila in nas pozove naj uredimo komentar commit-a.
+Lahko se odločiš, da pustiš privzeto sporočilo Git-a, ki se začne z besedo `Revert`, ali pa spremeniš komentar po svojih željah.
+
+*   Nato shranimo in zapremo urejevalnik besedila.
+*   Vrnemo se v ukazno vrstico.
+*   Uporabimo ukaz ```git push origin <branch-name>``` da pošljemo spremembe na GitHub.
+
+In to je to, spremembe bodo odstranjene. V tem primeru bi se moj repository povrnil na stanje v commit-u ```c1b9fc1```.
@@ -0,0 +1,94 @@
+# Kaj je stiskanje?
+
+V Git-u stiskanje ( squashing ) pomeni popravljanje zgodovine svojih commit-ov, tako da na koncu ostaneš samo z enim commit-om in enim komentarjem narejenih sprememb.
+To je običajni postopek v odprto kodnih projektih, ker je velik del zgodovine vsake veje pomemben samo programerju, ki jo je ustvaril. Poleg tega na ta način poenostavimo sledenje izvedenih sprememb in jih tudi lažje povrnemo v prejšnje stanje, če je to potrebno. 
+
+# Kako stisneš commit-e?
+
+Najprej uporabimo ukaz `git log` da lahko pregledamp commit-e v svoji veji, ki bi jih rad združili ( merge ).
+
+```
+git log
+```
+
+Videti bi morali serijo commit-ov, kot na primer:
+
+```
+commit blablabla
+Author: omguhh
+Date:   10/10/20
+    Commit message 1
+
+commit blablabla2
+Author: omguhh
+Date:   10/10/20
+    Commit message 2
+```
+
+Sedaj, ko vidimo commit-e, ki jih želimo združiti v enega, lahko začnemo tako da uporabimo ukaz ```git rebase```. Predvidevam da že poznaš ukaz ```git rebase``` in lahko začnemo stiskanje commit-ov v interaktivnem načinu ukaza `git rebase`, ki ga aktiviramo tako:
+
+```
+git rebase -i
+```
+V interaktivnem načinu ukaza rebase lahko določimo začetno in končno točko do katere nazaj želimo iti. HEAD je začetna točka, "~2" pa pomeni da gremo dva commita nazaj v zgodovino. Ukaz se uporabi takole:
+
+```
+git rebase -i HEAD~2
+```
+
+Ko uporabimo ta ukaz, se nam bo prikazalo nekaj podobnega tem vrsticam:
+
+```
+pick blablabla Changing test01.txt file
+pick blablabla2 Adding dummy01.txt file
+
+#
+# Commands:
+#  p, pick = use commit
+#  r, reword = use commit, but edit the commit message
+#  e, edit = use commit, but stop for amending
+#  s, squash = use commit, but meld into previous commit
+#  f, fixup = like "squash", but discard this commit's log message
+#  x, exec = run command (the rest of the line) using shell
+#
+# These lines can be re-ordered; they are executed from top to bottom.
+#
+# If you remove a line here THAT COMMIT WILL BE LOST.
+#
+# However, if you remove everything, the rebase will be aborted.
+#
+# Note that empty commits are commented out
+```
+
+Ukazi navedeni v zgornjem sporočilu:
+- p, pick = uporabi commit
+- r, reword = uporabi commit, vendar uredi komentar
+- e, edit = uporabi commit, vendar se ustavi za spremembo
+- s, squash = uporabi commit, vendar ga stisni v prejšnji commit
+- f, fixup = enak kot "squash", vendar zavrzi komentar tega commit-a
+- x, exec = zaženi ukaz ( preostanek vrstice ) v shell-u
+
+To pomeni da, če želimo stisniti ```blablabla2``` v ```blablablabla```, bi zgornje sporočilo spremenili tako:
+
+```
+pick blablabla Changing test01.txt file
+squash blablabla2 Adding dummy01.txt file
+
+```
+
+Če gre vse po planu, dobimo rezultat, ki zgleda takole:
+
+```
+# This is a combination of 2 commits.
+# The first commit's message is:
+commit message 1
+
+# This is the 2nd commit message:
+
+commit message 2
+```
+
+To sporočilo lahko po želji spremenimo preden zapremo urejevalnik besedila, kar shrani spremembe.
+
+Če še enkrat uporabimo ukaz `git log`, bi morali dobiti komentar commit-a, ki smo ga vnesli preden smo zaprli urejevalnik besedila, in commit-i bi morali biti združeni v enega.
+
@@ -0,0 +1,136 @@
+# Shranjevanje za pozneje ( Stashing )
+
+Kaj storiti, če delaš na velikem projektu, in moraš nenadoma zamenjati vejo, na kateri trenutno delaš, za neko drugo vejo? Koda, na kateri si delal, ni dokončana in dokler je ne preveriš dobro, ne želiš izvesti commit. Vendar se ne moreš premakniti na drugo vejo brez da bi izvedel commit, Git ti ne pusti prekiniti delovni tok ( workflow ). Kaj storiti? Kako preprečiti nepotreben commit in hkrati preskočiti na drugo vejo? Na to vprašanje odgovarja ta vodič.
+
+## Shranjevanje svojega dela
+
+Predpostavimo da delaš na veji projekta, kjer si naredil nekaj spremembe. Če uporabiš ukaz ```git status```, lahko vidiš kje so bile spremembe narejene.
+
+```
+$ git status
+# On branch master
+# Changes to be committed:
+#   (use "git reset HEAD <file>..." to unstage)
+#
+#      modified:   index.html
+#
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   lib/simplegit.rb
+#
+```
+Sedaj se želiš prestaviti na drugo vejo, vendar še nočeš izvesti commit s temi spremembami. Zato bi shranil spremembe za pozneje ( stash ).
+Spremembe lahko shraniš na svoj stack z uporabo ukaza ```git stash```:
+
+```
+$ git stash
+Saved working directory and index state \
+  "WIP on master: 049d078 added the index file"
+HEAD is now at 049d078 added the index file
+(To restore them type "git stash apply")
+```
+
+Sedaj je tvoje delovno okolje ( working directory ) čisto. To lahko preveriš z uporabo ukaza ```git status```:
+
+```
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+
+Sedaj se lahko prestaviš na katerokoli vejo in delaš naprej; tvoje shranjene spremembe so shranjene na stack-u. Spremembe, ki so shranjene na stack-u, si lahko ogledaš z uporabo ukaza ```git stash list```:
+
+```
+$ git stash list
+stash@{0}: WIP on master: 049d078 added the index file
+stash@{1}: WIP on master: c264051 Revert "added file_size"
+stash@{2}: WIP on master: 21d80a5 added number to log
+```
+
+V primeru da želiš uveljaviti (re-apply) spremembe, ki si jih ravnokar shranil, lahko uporabiš ukaz ```git stash apply```. S tem ukazom lahko uveljaviš zadnjo shranjeno spremembo. Če želiš uveljaviti katerokoli drugo spremembo, jo moraš točno določiti: ```git stash apply <stash-name>```, kjer je ```<stash-name>``` ime spremembe, ki jo želiš uveljaviti.
+
+```
+$ git stash apply
+# On branch master
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   index.html
+#      modified:   lib/simplegit.rb
+#
+```
+
+Git je sedaj spremenil datoteko, ki smo jo povrnili v prvotno stanje, ko smo spremembe shranili v stack. V tem primeru smo imeli čisto delovno okolje, ko smo poskusili uveljaviti stash, in uveljavili smo jih na isti veji, s katere smo jih shranili. Nič od tega, čisto delovno okolje in ista veja, ni nujno da uveljavimo spremembe iz stasha. Spremembe lahko shranimo na eni veji, se prestavimo na drugo vejo in tam uveljavimo iste spremembe. Lahko bi tudi spremenili ali odstranili datoteke v svojem delovnem okolju, ko bi uveljavili stash. V primeru da pride do sporov pri združevanju shranjenih sprememb v obstoječe datoteke, bo Git te spore javil.
+
+Spremembe so bile uveljavljene, vendar datoteka, ki je bila pripravljena za commit, sedaj ni več pripravljena. Da dosežemo še to, moramo uporabiti ukaz ```git stash apply``` z ```--index```, da sporočimo ukazu da mora uveljaviti tudi to stanje. Ko uporabimo ta ukaz, se vrnemo v točno tako stanje, kot je bilo na začetku:
+
+```
+$ git stash apply --index
+# On branch master
+# Changes to be committed:
+#   (use "git reset HEAD <file>..." to unstage)
+#
+#      modified:   index.html
+#
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   lib/simplegit.rb
+#
+```
+
+Ukaz `apply` samo uveljavi spremembe, ki so bile shranjene, vendar te še vedno ostanejo na stack-u. Z ukazom ```git stash list``` si lahko prikažeš vsebino stack-a. Da nekaj z njega zbrišemo, uporabimo ukaz ```git stash drop```, ki mu dodamo ime stash-a.
+
+```
+$ git stash list
+stash@{0}: WIP on master: 049d078 added the index file
+stash@{1}: WIP on master: c264051 Revert "added file_size"
+stash@{2}: WIP on master: 21d80a5 added number to log
+$ git stash drop stash@{0}
+Dropped stash@{0} (364e91f3f268f0900bc3ee613f9f733e82aaed43)
+```
+
+Z ukazom ```git stash pop``` lahko hkrati uveljavimo spremembe in jih odstranimo s stack-a.
+
+## Razveljavljanje Stash-a
+
+V nekaterih primerih hočeš uveljaviti shranjene spremembe, nekaj narediti, in razveljaviti spremembe, ki so prišle iz stash-a. Git nima ukaza ```git unapply```, vendar je možno doseči isti učinek z kombiniranjem ukazov. Najprej prikažemo željeni stash in ga nato vzratno uveljavimo:
+
+```$ git stash show -p stash@{0} | git apply -R```
+
+Če ne določimo, kateri stash želimo, Git predvideva da želimo zadnjega:
+
+```$ git stash show -p | git apply -R```
+
+Lahko ustvariš alias in v bistvu dodaš ukaz ```stash-unapply``` v svoj Git. Na primer:
+
+```
+$ git config --global alias.stash-unapply '!git stash show -p | git apply -R'
+$ git stash apply
+$ #... work work work
+$ git stash-unapply
+```
+
+## Ustvari vejo iz Stash-a
+
+Če si shranil spremembe in jih nekaj časa pustil pri miru, vmes pa delal naprej na veji s katere si jih shranil, se ti lahko naredi da boš imel težave z uveljaljanjem sprememb. Če uveljavljaš spremembe na datoteki, ki si jo vmes spremenil, boš dobil spor pri združevanju in ga boš moral razrešiti. Obstaja lažji način povračanja sprememb iz stash-a z uporabo ukaza ```git stash branch```, ki ustvari novo vejo, pridobi commit na katerem si bil, ko si shranil spremembe, na njem uveljavi spremembe in potem zbriše stash, če je bil uspešno uveljavljen:
+
+```
+$ git stash branch testchanges
+Switched to a new branch "testchanges"
+# On branch testchanges
+# Changes to be committed:
+#   (use "git reset HEAD <file>..." to unstage)
+#
+#      modified:   index.html
+#
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   lib/simplegit.rb
+#
+Dropped refs/stash@{0} (f0dfc4d5dc332d1cee34a634182e168c4efc3359)
+```
+
+To je prikladna bližnjica s katero lahko enostavo pridobimo shranjene spremembe in jih uporabimo v novi veji.
@@ -0,0 +1,55 @@
+# Razveljavljanje lokalnega commit-a
+
+Vse kar rabiš storiti, da razveljaviš lokalni commit, je:
+```
+git reset
+```
+Ta ukaz bo resetiral stanje v čakalnici na tvoj zadnji commit, vendar bodo spremembe ostale v delovnem okolju. Če želiš, lahko ponovno ustvariš commit s temi spremembami.
+Lahko pa tudi odstraniš samo eno datoteko s svojega prejšnjega commit-a. Uporabiš ukaz:
+```
+git reset <file>
+```
+Ukaz bo odstranil samo določeno datoteko s čakalnice, vendar bodo spremembe narejene na datoteki ostale.
+
+Primer uporabe ```git reset```:
+```
+# Make changes in index.php and tutorial.php
+# Add files into the staging area
+$ git add .
+# Remembered both files need to be committed separately
+# Unstage tutorial.php
+$ git reset tutorial.php
+# Commit index.php first
+$ git commit -m "Changed index.php"
+# Commit tutorial.php now
+$ git add tutorial.php
+$ git commit -m "Changed tutorial.php"
+```
+
+Predpostavimo da si pokvaril svoj lokalni repository in ga želiš resetirati na svoj zadnji commit.
+Lahko uporabiš spodnji ukaz:
+```
+git reset --hard
+```
+Ukaz bo izpraznil čakalnico in tudi povrnil vse spremembe v datotekah na stanje v zadnjem commit-u.
+Možnost ```--hard``` pove Git-u da mora odstraniti tudi vse spremembe v delovnem okolju.
+Ta ukaz uporabi samo takrat, ko si prepričan da želiš odstraniti vse spremembe nastale od zadnjega commit-a!
+
+Primer uporabe ukaza ```git reset --hard```:
+```
+# Decided to start a crazy experiment
+# Create a new file 'crazy.php' and add some code to it
+# Commit crazy.php
+$ git add crazy.php
+$ git commit -m "Started a crazy dev"
+# Edit crazy.php file again and changed a lot other files
+# Commit all tracked files
+$ git add .
+$ git commit -m "Continued dev"
+# Tested and things went out of hand
+# Decided to remove the whole thing
+$ git reset --hard HEAD~2
+```
+Ukaz ```git reset --hard HEAD~2``` premakne trenutno vejo nazaj za 2 commit-a in hkrati povrne vse spremembe na to točko. Odstrani tudi 2 posnetka, ki smo ju ravnokar ustvarili iz zgodovine projekta.
+
+P.s: Nikoli ne izvedi ```git reset --hard``` , če si že poslal svoje commit-e v skupni repository, ker boš s tem ustvaril probleme vsem, ki uporabljajo ta repository!