#set page("a4", margin: 20mm)
#set text(lang: "sl")
#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge
#import fletcher.shapes: house, chevron, pill

#align(center)[
= Git kot usmerjen aciklični graf
]

// Končna delna ureditev ()
- #link("https://git-scm.com/")[Git] je sistem za nadzor različic.
- *Spremembe* beležimo z *vnosi* (angl. *commit*).
- Vnosi predstavljajo *usmerjen acikličen graf (DAG)*. 
- Vsak *vnos* predstavlja *vozlišče* v grafu. 
- Vnosi imajo lahko enaga ali več *starševskih* vnosov iz katerih izhajajo.
- *Povezave* v acikličnem grafu povezujejo vnose z njihovimi starši.

#figure(
  diagram(node-stroke: 1pt, node-shape: pill,
    {
      let (A, B, C, D, E, F, G) = ((0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (2, 1), (3, 1))
      node(A, "A")
      node(B, "B")
      node(C, "C")
      node(D, "D")
      node(E, "E")
      node(F, "F")
      node(G, "G")
      edge(B, A, "->")
      edge(C, B, "->")
      edge(D, C, "->")
      edge(E, D, "->")
      edge(G, F, "->")
      edge(F, B, "->")
      edge(D, F, "->")

    }
  ),
  caption: [Vnosi v Git kot usmerjen graf]
)

== Vnosi v Gitu

Vsak vnos v Gitu predstavlja vsebino datotek v določenem trenutku. Obenem je vnos določen s spremembami med vsebino datotek v prejšnjem vnosu in vsebino datotek v trenutnem vnosu. Interno git hrani spremembe kot posebne vrste #link("https://git-scm.com/book/en/v2/Git-Internals-Git-Objects")[git objektov].

#figure(
  table(columns: 1, [*Zgoščena vrednost*: 7c73a28b50d4aeb094d],
[*Avtor*: Martin Vuk `<martin@example.com>`],
[*Datum*:   Thu Sep 4 16:20:18 2025 +0200],
[*Opis*: Zamenjaj besedi perica in raca!], 
  [*Spremembe*:
```diff
--- a/foo.bar
+++ b/foo.bar
@@ -1 +1 @@
-Perica reže raci rep.
+Raca reže perici rep.
```],
stroke: 1pt, align: left),  
  caption: [Primer vnosa v Gitu. V datoteki `foo.bar` zamenjamo besedi `perica` in `raca`.],
)

== Osnove Gita

- *Vnos* (angl. *commit*): 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*): 40-mestna heksadecimalna vrednost, izračunana s SHA-1, ki enolično identificira vnos na podlagi njegove vsebine.
- *Veja* (angl. *branch*): 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*): 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.

#figure(
  diagram(node-stroke: 1pt, node-shape: pill, 
    {
      let (A, B, C) = ((0, 0), (1.5, 0), (3, 0))
      let (T, Br) = ((1, 1), (3, 1))
      let vnosi = (5, 0)
      let prvi = (-1, 1)
      node(prvi, [prvi vnos], stroke: 0pt)
      node(A, "0af3de")
      node(B, "11ea3a")
      node(C, "730a1e")
      node(vnosi, [vnosi], stroke: 0pt)
      node(T, "v1.01", stroke: 1pt, fill: green.lighten(50%),  shape: chevron)
      node(Br, "main", stroke: 1pt, fill: purple.lighten(50%), shape: chevron)
      edge(prvi, A, "-")
      edge(B, A, "->", [starš])
      edge(C, B, "->", [starš])
      edge(T, B, "-", [oznaka], label-pos: 25%)
      edge(Br, C, "-", [veja])
      node(enclose: (A, C), stroke: 0.3pt, shape: rect)
    }
  ),
  caption: [Osnovni pojmi Gita]
)


== Ukazi v git

== Git add

Zabeleži spremembe, ki bodo vključene v naslednji vnos:

```
git add foo.bar
```

#figure(
  diagram(node-shape: rect, node-stroke: 1pt,
    {
      let (A, B, C) = ((0,0), (1, 0), (2, 0))
      node(A, [`+baz`])
      node(B, [
```
-baz
+baaz
```])
      node(C, [
```
-baaz
+zaab
```], stroke: (dash: "dashed"))
      edge(B, A, "->")
      edge(C, B, "->", stroke: (dash: "dashed"))
      edge(B, A, "->")

    }
  ),
  caption: [Zabeleži, katere spremembe bodo v naslednjem vnosu.]
)

Ustvari *čakalnico* za spremembe, ki bodo vpisane naslednjem vnosu
(angl. *staging area*).
== Git commit

Spremembe zapiši v nov *vnos* (*commit*):

```
git commit -m "Spremeni baaz v zaab!"
```

#figure(
  diagram(node-shape: rect, node-stroke: 1pt,
    {
      let (A, B, C) = ((0,0), (1, 0), (2, 0))
      node(A, [`+baz`])
      node(B, [
```
-baz
+baaz
```])
      node(C, [
```
-baaz
+zaab
```], stroke: 2pt + blue)
      edge(B, A, "->")
      edge(C, B, "->", stroke: blue)
      edge(B, A, "->")

    }
  ),
  caption: [Zapiši spremembe v nov vnos]
)

Ustvari novo vozlišče v grafu.
== Ukazi kot operacije na DAG-u

- *Commit*  
  - Ustvari novo vozlišče v DAG.  

- *Merge*  
  - Novo vozlišče z več starši.  

#figure(
  diagram(
    {
      let (A, B, C, D, E, M) = ((0, 0), (1, 0), (2, 0), (1, 1), (2, 1), (3, 0))
      node(A, "A")
      node(B, "B")
      node(C, "C")
      node(D, "D")
      node(D, "M")
      edge(B, A, "->")
      edge(C, B, "->")
      edge(D, A, "->")
      edge(E, D, "->")
      edge(M, E, "->")
      edge(M, C, "->")
    }
  ),
  caption: [Merge: vnos M ima dva starša (C in E).]
)

- *Rebase*  
  - Premakne zaporedje vnosov na novo osnovo.  

#figure(
  diagram(
    {
      let (A, B, C1, D, C2) = ((0, 0), (1, 0), (1, 1), (2, 0), (3, 0))
      node(A, "A")
      node(B, "B")
      node(C1, "C (pred rebase)")
      node(D, "D")
      node(C2, "C (po rebase)")
      edge(B, A, "->")
      edge(C1, B, "->")
      edge(D, A, "->")
      edge(C2, D, "->")
    }
  ),
  caption: [Rebase: commit C se premakne, da temelji na D.]
)

- *Reset*  
  - Premakne oznako veje na drug commit.  

#list[
- *commit* → novo vozlišče v DAG
- *merge* → združitev dveh vej
- *rebase* → prestavi zaporedje na drugo osnovo
- *reset* → premik oznake (branch)
]

== Povzetek
#table(
  columns: 2,
  [Ukaz], [Pomen v kontekstu DAG],
  [commit], [Novo vozlišče, povezano s staršem],
  [merge], [Novo vozlišče z več starši],
  [rebase], [Prepis poti v grafu],
  [reset], [Premik branch oznake]
)