From 191f5c4bd37267989460142f64181c9b39be8ae4 Mon Sep 17 00:00:00 2001 From: Martin Vuk Date: Tue, 9 Dec 2025 02:43:43 +0100 Subject: [PATCH] Add intro and figure --- git-figure.typ | 90 +++++++++++++++++++ git-intro.typ | 232 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 322 insertions(+) create mode 100644 git-figure.typ create mode 100644 git-intro.typ diff --git a/git-figure.typ b/git-figure.typ new file mode 100644 index 0000000..31423bf --- /dev/null +++ b/git-figure.typ @@ -0,0 +1,90 @@ +#set text(lang: "sl") +#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge +#import fletcher.shapes: house, chevron, pill, hexagon + +#diagram(debug: 1, node-stroke: 2pt, edge-stroke: 1pt, + { + let store = (1, 7) + let (A, B, C, D, E, F, G) = ((2, 6), (2, 5), (2, 4), (2, 3), (2, 2), (2, 1), (2, 0)) + let (B1, B2) = ((3, 4.5), (3, 3.5)) + let (E1, E2, E3) = ((3, 1.5), (3, 0.5), (3, -0.5)) + let (Br1, Br2) = ((1, G.at(1)), (2.5, E2.at(1))) + let (T1, T2) = ((1, E.at(1)), (1, B.at(1))) + let refs = (3, 7) + node(store, [Content addressable object store], width: 3cm) + node(A, [A 16f299], shape: pill, name: ) + node(B, [B 16f299], shape: pill) + node(C, [C 16f299], shape: pill) + node(D, [D 16f299], shape: pill) + node(E, [E 16f299], shape: pill) + node(F, [F 16f299], shape: pill) + node(G, [16f299], shape: pill) + // merged branch + node(B1, [B1 16f299], shape: pill) + node(B2, [B2 16f299], shape: pill) + // unmerged branch + node(E1, [E1 16f299], shape: pill) + node(E2, [E2 16f299], shape: pill) + node(E3, [E3 16f299], shape: pill, stroke: (dash: "dashed")) + // branches + node(Br1, [main], shape: hexagon, stroke: purple) + node(Br2, [hotfix], shape: hexagon, stroke: purple) + // tags + node(T1, [v-1.0], shape: chevron, stroke: green) + node(T2, [v-1.1], shape: chevron, stroke: green) + // refs + node(refs, stroke: none, snap: false, enclose: (refs, (refs.at(0)+2, refs.at(0)+2)), + table(columns: 1, align: left, [*References* (`.git/refs`)], [*Tags* (`.git/refs/tags`)\ `tag-1`: `8dd6d4b...`], [*Branches* (`.git/refs/heads`) \ `main`: `8dd6d4b...`\ + `feature-1`: `8dd6d4b...`\ + `hotfix`: `8dd6d4b...`]) + ) + let branches = (2, -2) + node(branches, [#text(stroke: purple.darken(50%))[BRANCH]\ reference that moves when commiting canges], + stroke: 0.5pt, corner-radius: 10pt, inset: 0pt, width: 1cm, enclose: ((2, -2), (3, -2))) + let tags = (0, 3.5) + node(tags, [#text(stroke: green.darken(50%))[TAG]\ reference that don't move], + stroke: 0.5pt, corner-radius: 10pt, inset: 0pt, width: 1cm, enclose: ((0, 3.5), (1, 4.5))) + let commit = (3.5, 2.5) + node(commit, [ + *COMMIT*\ snapshot of filesystem tree in object store\ + #rect[ + ``` +tree 65c47fee... +parent 16f299... +author MV ") + edge(C, B, "->") + edge(D, C, "->") + edge(E, D, "->") + edge(F, E, "->") + edge(G, F, "->") + // merged branch + edge(B1, B, "->", layer: 1) + edge(B2, B1, "->") + edge(D, B2, "->") + // unmerged branch + edge(E1, E, "->") + edge(E2, E1, "->") + edge(E3, E2, "->", stroke: (dash: "dashed")) + // refs + edge(Br1, G) + edge(Br2, E2) + edge(T1, E) + edge(T2, B) + edge(Br1, branches, stroke: 0.5pt) + edge(Br2, branches, stroke: 0.5pt) + edge(T1, tags, stroke: 0.5pt) + edge(T2, tags, stroke: 0.5pt) + edge(commit, E, stroke: 0.5pt) + } +) \ No newline at end of file diff --git a/git-intro.typ b/git-intro.typ new file mode 100644 index 0000000..bc0ea31 --- /dev/null +++ b/git-intro.typ @@ -0,0 +1,232 @@ +#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 ``], +[*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] +) \ No newline at end of file