Dopolni poglavje o referencah

git-intro.typ

@@ -18,26 +18,6 @@ kako stvari delujejo.
 #note[Git hrani vsebino direktorija z datotekami in celotno zgodovino sprememb.
 Zgodovina sprememb se hrani v obliki posnetkov celotne vsebine v določenih trenutkih.]
 
-== Za neučakane
-Samostalniki:
-- *Vnos* (angl. *commit*) je posnetek trenutnega stanja projekta, shranjen kot vozlišče v zgodovinskem grafu (DAG), ki vsebuje spremembe datotek ter metapodatke (avtor, čas, sporočilo).
-- *Zgoščena vrednost vnosa* (angl. *commit hash*) je 40-mestna heksadecimalna vrednost, izračunana s SHA-1, ki enolično identificira vnos na podlagi njegove vsebine.
-- *Veja* (angl. *branch*) je premična oznaka, ki kaže na določen vnos v zgodovini in se samodejno premakne naprej, ko dodajamo nove vnose. Veje omogočajo vzporedne razvojne linije z različnimi spremembami.
-- *Oznaka* (angl. *tag*) je statična oznaka, ki trajno kaže na določen vnos. Za razliko od veje se oznaka, nikoli ne premika samodejno, zato se uporablja predvsem za označevanje pomembnih točk v zgodovini, kot so izdaje ali stabilne verzije.
-- *Delovna kopija* (angl. *workout copy*) je direktorij v katerem urejamo datoteke, ki jih nato vnesemo v Git. V delovni kopiji imajo na začetku datoteke isto vsebino kot je vsebina trenutno aktivnega vnosa (`HEAD`). Spremembe, ki jih naaredimo na delovni kopiji lahko zabeležimo v nov vnos.  
-- *Oddaljen repozitorij* (angl. *remote*) je povezava(url) na oddaljen repozitorij, s katerim izmenjujemo vsebino.
-
-Glagoli (akcije):
-- *Checkout* prenese vsebino vnosa v delovno kopijo: `git checkout neka-veja` 
-- *Commit* ustvari nov vnos: `git commit -m 'Sporočilo'`
-- *Add* doda vsebino, ki bo v naslednjem vnosu: `git add dodaj_me.txt`
-- *Pull* poberi vsebino iz oddaljenega repozitorija in uskladi lokalno vejo z oddaljeno: `git pull`
-- *Push* potisni lokalne vnose na oddaljeni repozitorij in uskladi oddaljeno vejo z lokalno: `git push`
-- *Fetch* pobere nove vnose, veje in oznake iz oddaljenega repozitorija: `git fetch`
-- *Reset* spremeni kam kaže trenutno izbrana veja: `git reset a239f9e91`
-- *Merge* ustvari nov vnos, ki združi dve ločeni veji v eno: `git merge main`
-- *Rebase* prestavi vnose v trenutno izbrani veji na izbran vnos: `git rebase main`
-
 == Vnos: posnetek stanja
 Osnovna enota v Gitu je  *Vnos* (angl. *commit*). Vnos je posnetek stanja zabeleženih datotek v trenutku,
 ko je bil ustvarjen. Poleg vsebine datotek vsak vnos vsebuje še metapodatke o avtorju, datumu vnosa in opisom
@@ -75,7 +55,7 @@ Skladišča objektov v Gitu je
 #link("https://en.wikipedia.org/wiki/Content-addressable_storage")[skladišče vsebinsko naslovljivih objektov]. 
 Dostop do objekta je mogoč, če poznamo *zgoščeno vrednost* njegove vsebine. To pomeni, da je referenca na 
 posamezen objekt v Gitu preprosto zgoščena vrednost(angl. hash) vsebine tega objekta. Po drugi strani je
-vsebina objekta določena z njegovo zgoščeno vrednostjo. To pomeni, da lahko enostavno preverimo verodostojnost vsebine, ki je shranjena v Gitu. 
+vsebina objekta določena z njegovo zgoščeno vrednostjo. To pomeni, da lahko enostavno preverimo verodostojnost vsebine, ki je shranjena v Gitu. Git hrani skladišče objektov v direktoriju `.git/objects`.
 ] 
 == Zgodovinski graf sprememb  
 Posamezni vnosi so povezani v *usmerjen acikličen graf (DAG)*, ki predstavlja zgodovino sprememb. 
@@ -108,100 +88,109 @@ Vsak *vnos* je *vozlišče* v grafu. Vsak vnos izhaja iz enega ali več staršev
 
 == Reference: veje in značke
 
-V delu!
+Poleg objektov kot so _vnosi_, _posnetki direktorijev_ in _posnetki datotek_ pozna git še reference. Reference so kazalci z določenim imenom na posamezen vnos.
-
-== Ukazi v git
-
-Za konec so še kratke ilustracije kaj v Gitu počnejo posamezni ukazi.
-
-== Git add
-
-Zabeleži spremembe, ki bodo vključene v naslednji vnos:
-
-```
-git add foo.bar
-```
 
 #figure(
-  diagram(node-shape: rect, node-stroke: 1pt,
+  diagram(node-stroke: 0.5pt,
-    {
+  {
-      let (A, B, C) = ((0,0), (1, 0), (2, 0))
+    node((2, -1), [main], shape: chevron, name: <main>)
-      node(A, [`baz`])
+    node((-1, 0), [`e23d19`], shape: pill, name: <commit1>)
-      node(B, [
+    node((0, 0), [`3943eb`], shape: pill, name: <commit2>)
-```
+    node((1, 0), [`98ff21`], shape: pill, name: <commit3>)
-baaz
+    node((2, 0), [`4e96a1`], shape: pill, name: <commit4>)
-```])
+    node((0, 1), [v-1.0], shape: chevron.with(dir: left), name: <tag>)
-      node(C, [
+    edge(<commit2>, <commit1>, "->")
-```
+    edge(<commit3>, <commit2>, "->")
-zaab
+    edge(<commit4>, <commit3>, "->")
-```], stroke: (dash: "dashed"))
+    edge(<main>, <commit4>, "->")
-      edge(B, A, "->")
+    edge(<tag>, <commit2>, "->")
-      edge(C, B, "->", stroke: (dash: "dashed"))
+  }
-      edge(B, A, "->")
-
-    }
   ),
-  caption: [Zabeleži, katere spremembe bodo v naslednjem vnosu.]
+  caption: [Veja (angl. branch) ali značka(angl. tag) je preprost kazalec na posamezen vnos(angl. commit). ]
 )
 
-Ustvari *čakalnico* za spremembe, ki bodo vpisane naslednjem vnosu
+Referenc git ne hrani v skladišču objektov, temveč posebej v direktoriju `.git/refs`. Zato so reference vezane na posamezen repozitorij in se lahko razlikujejo med različnimi kloni določenega repozitorija. 
-(angl. *staging area*).
-== Git commit
 
-Spremembe zapiši v nov *vnos* (*commit*):
+*Veja* (angl. *branch*) je posebne vrste referenca, ki se premika, ko dodajamo nove vnose. Vsakič ko ustvarimo nov vnos, se trenutno aktivna veja premakne na novo ustvarjeni vnos. 
 
-```
+*Značka* (angl. *tag*) je referenca, ki je statična in se ne premika več, ko jo enkrat ustvarimo.
-git commit -m "Spremeni baaz v zaab!"
-```
 
 #figure(
-  diagram(node-shape: rect, node-stroke: 1pt,
+  diagram(node-stroke: 0.5pt,
-    {
+  {
-      let (A, B, C) = ((0,0), (1, 0), (2, 0))
+    node((1, -1), [main], shape: chevron, name: <main-old>, stroke:(dash: "dotted"))
-      node(A, [`baz`])
+    node((-1, 0), [`e23d19`], shape: pill, name: <commit1>)
-      node(B, [
+    node((0, 0), [`3943eb`], shape: pill, name: <commit2>)
-```
+    node((1, 0), [`98ff21`], shape: pill, name: <commit3>)
-baaz
+    node((2, 0), [`4e96a1`], shape: pill, name: <commit4>, stroke: blue)
-```])
+    node((2, -1), [main], shape: chevron, name: <main>)
-      node(C, [
+    node((1, 1), [v-1.0], shape: chevron, name: <tag>)
-```
+    edge(<commit2>, <commit1>, "->")
-zaab
+    edge(<commit3>, <commit2>, "->")
-```], stroke: 2pt + blue)
+    edge(<commit4>, <commit3>, "->", stroke: blue)
-      edge(B, A, "->")
+    edge(<main-old>, <commit3>, "->", stroke: (dash: "dotted"))
-      edge(C, B, "->", stroke: blue)
+    edge(<tag>, <commit3>, "->")
-      edge(B, A, "->")
+    edge(<main>, <commit4>, "->")
-
+  }
-    }
   ),
-  caption: [Zapiši spremembe v nov vnos]
+  caption: [Ko ustvarimo nov vnos, se aktivna veja `main` premakne naprej, značka `v-1.0` pa ostane tam, kjer je bila. ]
 )
 
-Ustvari novo vozlišče v grafu.
+#note[
+Veje in značke nimajo v Gitu nobenega posebnega pomena, razen tega, da so reference na vnose. Pomen posamenznih vej je stvar dogovora med uporabniki. Tako se pogosto uporablja različne veje za različne namene: `main` ali `master` je navadno glavna veja razvoja, veje z imeni `stable`, `production`, `development` in podobno označujejo različne stopnje razvoja programske opreme, veje s predpono `feature-` označujejo razvoj novih funkcionalnosti. 
 
+Vse te pomene damo vejam ljudje, ki sodelujemo v nekem Git repozitoriju. Za Git so vse veje in značke zgolj preprosti kazalci na določen vnos. 
+]
 
-== Git Rebase  
+*HEAD* je posebna referenca, ki kaže na trenutno aktiven vnos. Vnos, na katerega kaže _HEAD_ bo starševski vnos naslednjeg vnosa, ki ga bomo dodali.
-Premakne zaporedje vnosov na novo osnovo.  
 
 #figure(
-  diagram(node-shape: pill, node-stroke: 0.5pt,
+  diagram(node-stroke: 0.5pt,
-    {
+  {
-      let (A, B, C1, D, C2) = ((0, 0), (1, 0), (1, 1), (2, 0), (3, 0))
+    node((-1, 0), [`e23d19`], shape: pill, name: <commit1>)
-      node(A, "A")
+    node((0, 0), [`3943eb`], shape: pill, name: <commit2>)
-      node(B, "B")
+    node((1, 0), [`98ff21`], shape: pill, name: <commit3>)
-      node(C1, "C (pred rebase)", stroke: (dash: "dashed"))
+    node((2, 0), [`4e96a1`], shape: pill, name: <commit4>, stroke: (dash: "dotted"))
-      node(D, "D")
+    node((1, -1), [main], shape: chevron, name: <main>)
-      node(C2, "C (po rebase)", stroke: blue)
+    node((1, 1), [HEAD], shape: chevron, name: <head>)
-      edge(B, A, "->")
+    node((2, 1), [index], shape: rect, name: <index>, stroke: (dash: "dotted"))
-      edge(C1, B, "->", stroke: (dash: "dashed"))
+
-      edge(D, B, "->")
+    edge(<commit2>, <commit1>, "->")
-      edge(C2, D, "->", stroke: blue)
+    edge(<commit3>, <commit2>, "->")
-    }
+    edge(<commit4>, <commit3>, "->", stroke: (dash: "dotted"))
+    edge(<index>, <commit4>, "->", stroke: (dash: "dotted"))
+    edge(<head>, <commit3>, "->")
+    edge(<main>, <commit3>, "->")
+  }
   ),
-  caption: [Rebase: commit C se premakne, da temelji na D.]
+  caption: [*HEAD* je referenca na trenutno aktiven vnos/vejo.]
 )
 
-== Git Reset  
+== Povzetek
+Samostalniki:
+- *Vnos* (angl. *commit*) je posnetek trenutnega stanja projekta, shranjen kot vozlišče v zgodovinskem grafu (DAG), ki vsebuje spremembe datotek ter metapodatke (avtor, čas, sporočilo).
+- *Zgoščena vrednost vnosa* (angl. *commit hash*) je 40-mestna heksadecimalna vrednost, izračunana s SHA-1, ki enolično identificira vnos na podlagi njegove vsebine.
+- *Veja* (angl. *branch*) je premična oznaka, ki kaže na določen vnos v zgodovini in se samodejno premakne naprej, ko dodajamo nove vnose. Veje omogočajo vzporedne razvojne linije z različnimi spremembami.
+- *Oznaka* (angl. *tag*) je statična oznaka, ki trajno kaže na določen vnos. Za razliko od veje se oznaka, nikoli ne premika samodejno, zato se uporablja predvsem za označevanje pomembnih točk v zgodovini, kot so izdaje ali stabilne verzije.
+- *Delovna kopija* (angl. *workout copy*) je direktorij v katerem urejamo datoteke, ki jih nato vnesemo v Git. V delovni kopiji imajo na začetku datoteke isto vsebino kot je vsebina trenutno aktivnega vnosa (`HEAD`). Spremembe, ki jih naaredimo na delovni kopiji lahko zabeležimo v nov vnos.  
+- *Oddaljen repozitorij* (angl. *remote*) je povezava(url) na oddaljen repozitorij, s katerim izmenjujemo vsebino.
 
-Premakne oznako veje na drug commit.  
+Glagoli (akcije):
+- *Checkout* prenese vsebino vnosa v delovno kopijo: `git checkout neka-veja` 
+- *Commit* ustvari nov vnos: `git commit -m 'Sporočilo'`
+- *Add* doda vsebino, ki bo v naslednjem vnosu: `git add dodaj_me.txt`
+- *Pull* poberi vsebino iz oddaljenega repozitorija in uskladi lokalno vejo z oddaljeno: `git pull`
+- *Push* potisni lokalne vnose na oddaljeni repozitorij in uskladi oddaljeno vejo z lokalno: `git push`
+- *Fetch* pobere nove vnose, veje in oznake iz oddaljenega repozitorija: `git fetch`
+- *Reset* spremeni kam kaže trenutno izbrana veja: `git reset a239f9e91`
+- *Merge* ustvari nov vnos, ki združi dve ločeni veji v eno: `git merge main`
+- *Rebase* prestavi vnose v trenutno izbrani veji na izbran vnos: `git rebase main`
 
+== Delo z Git
+
+Opis dela z Gitom presega namen tega dokumenta. Zato vas raje preusmerimo na uradno dokumentacijo:
+
+#align(center, text(size: 1.5em)[https://git-scm.com/cheat-sheet])
+
+Sledi še skica, ki povzame vse komponente Git repozitorija.
 #include "git-figure.typ"