203 lines
No EOL
9.7 KiB
Typst
203 lines
No EOL
9.7 KiB
Typst
#set text(lang: "sl")
|
|
#set page("a4", margin: 5mm)
|
|
#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge
|
|
#import fletcher.shapes: house, chevron, pill, hexagon
|
|
|
|
#let commit-color = green
|
|
#let tag-color = orange
|
|
#let branch-color = purple
|
|
#let thin = 0.5pt;
|
|
#let thindotted = (thickness: thin, dash: "dotted");
|
|
#let thindashed = (thickness: thin, dash: "dashed");
|
|
#let commit-node(coord, hash, ..args) = node(
|
|
coord, raw(hash), shape: pill, fill: commit-color.lighten(50%), stroke: thin, ..args)
|
|
#let commit-object(coord, hash, name, ..args) = node(
|
|
coord, align(left, [#text(size: 8pt, gray.darken(50%), raw(hash))\ #name]),
|
|
corner-radius: 7pt, fill: commit-color.lighten(50%), stroke: none, ..args)
|
|
#let tree-object(coord, hash, content, ..args) = commit-object(coord, hash, content,
|
|
width: 2cm, fill: blue.lighten(50%), ..args)
|
|
#let file-object(coord, hash, name, ..args) = commit-object(coord, hash, name,
|
|
width: 2cm, fill: gray.lighten(50%), ..args)
|
|
|
|
#diagram(
|
|
//debug: 1,
|
|
node-stroke: 2pt, edge-stroke: 1pt,
|
|
{
|
|
let x_0 = 2
|
|
let x_delta = 1
|
|
let x_1 = x_0 + 1.5
|
|
/*let store = (2cm, 2cm)
|
|
let (co1, co2) = {
|
|
let x = 2cm
|
|
let y = store.at(1)
|
|
((x, y+1.5cm), (x, y+1.5cm))
|
|
}
|
|
let (tree1, tree2) = {
|
|
let x = 3.2cm
|
|
((x, co1.at(1)), (x, co2.at(1)))
|
|
}
|
|
let (f1, f2, f3) = {
|
|
let x = 4.2cm;
|
|
let y = store.at(1)
|
|
((x, y), (x, y + 0.5cm), (x, y + 1cm))
|
|
}*/
|
|
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 (Ah, Bh, Ch, Dh, Eh, Fh, Gh) = ("0a3d36", "ce2d1d", "0459b3", "b62527", "93f4ee", "7b67bd", "a6eb69")
|
|
let (B1h, B2h) = ("2e4289", "7ed6de")
|
|
let (E1h, E2h, E3h) = ("aa083c", "3f28d1", "2e9986")
|
|
let tree1h = "43e2f7"
|
|
//e05dcdcb48cd0772313f")
|
|
/*
|
|
let refs = (12cm, store.at(1))
|
|
let tags = (0.5, 3)
|
|
let commit = (3.8, 2.5)
|
|
let branches = (0.5, 0)
|
|
let stage =(3.7, 0)
|
|
let mc = (2.5, D.at(1)-0.5)
|
|
commit-object(co1, "e264a1", [second commit])
|
|
commit-object(co2, "16f29", [first commit], width: 2.8cm)
|
|
tree-object(tree1, "16f29")
|
|
tree-object(tree2, "16f29")
|
|
file-object(f1, "16f29", [`new content`])
|
|
file-object(f2, "16f29", [`unchanged`])
|
|
file-object(f3, "16f29", [`first content`])
|
|
|
|
edge(co2, tree2, "->")
|
|
edge(co1, tree1, "->")
|
|
|
|
|
|
node(store, stroke: thin, enclose:(co1, f3, f1))
|
|
*/
|
|
commit-node(A, Ah, name: <A>)
|
|
node((rel:(-1, 0), to: <A>), [Initial commit], corner-radius: 10pt, stroke: thin, name:<initial>)
|
|
edge(<A>, <initial>, stroke: thindotted)
|
|
commit-node(B, Bh, name: <B>)
|
|
commit-node(C, Ch, name: <C>)
|
|
commit-node(D, Dh, name: <D>)
|
|
node((rel: (0.5, -0.5), to: <D>), [Merge commit\ #text(size: 8pt)[commit with two parents]], stroke: thin,
|
|
corner-radius: 10pt, name: <merge>)
|
|
edge(<merge>, <D>, stroke: thindotted)
|
|
|
|
commit-node(E, Eh, name: <E>)
|
|
commit-node(F, Fh, name: <F>)
|
|
// merge commit
|
|
// merged branch
|
|
commit-node((rel: (1, -0.5), to: <B>), B1h, name: <B1>)
|
|
commit-node((rel: (0, -1), to: <B1>), B2h, name: <B2>)
|
|
// unmerged branch
|
|
commit-node((rel: (1, -0.5), to: <E>), E1h, name: <E1>)
|
|
commit-node((rel: (0, -1), to: <E1>), E2h, name: <E2>)
|
|
commit-node((rel: (0, -1), to: <E2>), E3h, fill: none, stroke: thindashed, name: <E3>)
|
|
// branches
|
|
node((rel: (-1, 0), to: <F>), [main], shape: chevron, stroke: branch-color, name: <main>)
|
|
edge(<main>, <F>, "->", stroke: thin)
|
|
node((rel: (-2, 0), to: <E2>), [hotfix], shape: chevron, stroke: branch-color, name: <hotfix>)
|
|
edge(<hotfix>, <E2>, "->", stroke: thin)
|
|
// HEAD
|
|
node((rel: (0.5, 0), to: <E2>), [HEAD], shape:chevron.with(dir: left), stroke: blue, name: <head>)
|
|
edge(<head>, <E2>, "->", stroke: thin)
|
|
// tags
|
|
node((rel: (-1, 0), to: <E>), [v-2.0], shape: chevron, stroke: tag-color, name: <v2>)
|
|
edge(<v2>, <E>, "->", stroke: thin)
|
|
node((rel: (-1, 0), to: <B>), [v-1.0], shape: chevron, stroke: tag-color, name: <v1>)
|
|
edge(<v1>, <B>, "->", stroke: thin)
|
|
node((rel: (0.5, 0), to: <B2>), [v-1.1], shape:chevron.with(dir: left), stroke: tag-color, name: <v11>)
|
|
edge(<v11>, <B2>, "->", stroke: thin)
|
|
// enclose the tree
|
|
node((rel: (0, -1), to: <F>), [*Version history*\
|
|
#align(left, text(size: 10pt)[
|
|
_Directed Acyclic Graph (DAG)_ describes version history.
|
|
Commits are nodes in DAG. Commits are connected with their parents.
|
|
])], stroke:none, width: 5cm, name: <history>)
|
|
node(snap: false, enclose: (<A>, <history>, <E3>), stroke: thindashed, width: 3cm, fill: gray.lighten(70%))
|
|
// branch cloud
|
|
node((rel: (-0.5, -1), to: <hotfix>), [#text(branch-color.darken(20%), smallcaps[*Branches*])\ references that move along when commiting changes],
|
|
stroke: thin, corner-radius: 10pt, inset: 5pt, width: 4cm, name: <branch>)
|
|
edge(<branch>, <hotfix>, corner: left, stroke: thindotted)
|
|
edge(<branch>, <main>, corner: left, stroke: thindotted)
|
|
// tag cloud
|
|
node((rel: (-0.5, 1.5), to: <v2>), [#text(tag-color, smallcaps[*Tags*])\ references that don't move],
|
|
stroke: thin, corner-radius: 10pt, inset: 5pt, width: 4cm, name: <tag>)
|
|
edge(<tag>, <v2>, corner: right, stroke: thindotted)
|
|
edge(<tag>, <v1>, corner: left, stroke: thindotted)
|
|
// staging area
|
|
node((rel: (1, 0), to: <E3>), [#smallcaps[*Staging area (index)*]\ #text(size: 10pt)[filesystem snapshot that will be commited in
|
|
the next commit]], stroke: thindashed, corner-radius: 10pt, width: 4.5cm, name: <stage>)
|
|
edge(<E3>, <stage>, stroke: thindotted)
|
|
// head cloud
|
|
// staging area
|
|
node((rel: (0.5, 0.5), to: <head>), [#text(blue, smallcaps[*Head*])\ #text(size: 10pt)[reference to current branch parent to the next commit]], stroke: thin, corner-radius: 10pt, width: 4.5cm, name: <head-cloud>)
|
|
edge(<head>, <head-cloud>, stroke: thindotted)
|
|
// commit
|
|
node((rel: (1, 0.5), to: <E1>), [
|
|
#text(commit-color, smallcaps[*Commit*])\ file tree snapshot with metadata in object store\
|
|
#table(columns: 1, fill: commit-color.lighten(50%), align: left, [commit hash: #raw(E1h)],
|
|
raw(block: true, "
|
|
tree 65c47fee
|
|
parent 16f299
|
|
author Martin Vuk
|
|
committer MV <mv...
|
|
|
|
Add bla".replace("16f299", Eh).replace("65c47fee", tree1h)
|
|
)
|
|
)
|
|
], width:5cm, stroke: thin, corner-radius: 10pt, name: <commit>)
|
|
edge(<commit>, <E1>, corner: right, stroke: thindotted)
|
|
// refs
|
|
/*
|
|
node(refs, stroke: thin, inset:5pt, snap: false, enclose: (refs, (refs.at(0)+1cm, refs.at(1)+1cm)),
|
|
align(left, [
|
|
*References* (`.git/refs`)\ *Tags* (`.git/refs/tags`)\ `tag-1`: `8dd6d4b...`\ *Branches* (`.git/refs/heads`) \ `main`: `8dd6d4b...`\
|
|
`feature-1`: `8dd6d4b...`\
|
|
`hotfix`: `8dd6d4b...`
|
|
])
|
|
)
|
|
/*, enclose: (
|
|
(branches.at(0)-0.5, branches.at(1)),
|
|
(branches.at(0)+1, branches.at(1))))*/
|
|
/*, enclose: ((tags.at(0)-0.5, tags.at(1)), (tags.at(0)+1, tags.at(1))))*/
|
|
|
|
|
|
let ic = (A.at(0)+0.7, A.at(1)-0.2);
|
|
edge(ic, A, stroke: thindotted)
|
|
*/
|
|
// history
|
|
edge(<B>, <A>, "->")
|
|
edge(<C>, <B>, "->")
|
|
edge(<D>, <C>, "->")
|
|
edge(<E>, <D>, "->")
|
|
edge(<F>, <E>, "->")
|
|
// merged branch
|
|
edge(<B1>, <B>, "->", layer: 1, label: [parent], label-angle: auto)
|
|
edge(<B2>, <B1>, "->")
|
|
edge(<D>, <B2>, "->")
|
|
// unmerged branch
|
|
edge(<E1>, <E>, "->")
|
|
edge(<E2>, <E1>, "->")
|
|
edge(<E3>, <E2>, "->", stroke: (dash: "dashed"))
|
|
// object store
|
|
let bla_h = "d1bc32"
|
|
node((rel: (4cm, -2.5cm), to: <A>), align(center)[Content addressable object store \ #raw(".git/objects")], stroke: none, snap: false )
|
|
commit-object((rel: (1.5, 2), to: <A>), E1h, [Add bla], name: <obj-c1>)
|
|
commit-object((rel: (1.5, 3), to: <A>), Eh, [Merge commit], name: <obj-c2>)
|
|
tree-object((rel:(-1, 0), to: <obj-c1>), tree1h, [tree], name:<tree1>)
|
|
edge(<obj-c1>, <tree1>, stroke: thin, "->")
|
|
tree-object((rel:(-1, 0), to: <obj-c2>), "e05dcd",[tree], name: <tree2>)
|
|
edge(<obj-c2>, <tree2>, stroke: thin, "->")
|
|
file-object((rel:(-1, -0.5), to: <tree1>), "cb48cd", [`bla bla`], name: <f1>)
|
|
file-object((rel:(-1, 0.5), to: <tree1>), "077231", [`lorem`], name: <f2>)
|
|
file-object((rel:(-1, 1.5), to: <tree1>), bla_h, [`bla`], name: <f3>)
|
|
edge(<tree1>, <f2>, [`bar`], "->", label-angle: auto, stroke: thin)
|
|
edge(<tree1>, <f1>, [`foo`], "->", label-angle: auto, stroke: thin)
|
|
edge(<tree2>, <f2>, [`bar`], "->", label-angle: auto, stroke: thin)
|
|
edge(<tree2>, <f3>, [`foo`], "->", label-angle: auto, stroke: thin)
|
|
node((rel: (0, 0.5), to:<A>), enclose: (<obj-c2>, <f1>, <f3>), stroke: thindashed, corner-radius: 5pt,
|
|
fill: gray.lighten(70%), snap: false, layer: -2)
|
|
// time direction
|
|
edge((0.2, 2.5), (0.2, 1), "->", label: [time], label-side: left, label-angle: 90deg,
|
|
stroke: thindashed)
|
|
edge(<commit>, <obj-c1>, stroke: thin, "->", corner: right)
|
|
}
|
|
) |