Rebase
------
  git rebase origin/master

[graphviz]
----
digraph {
  // commit graph
  node [style=bold, shape=circle, color="#385d8a", fontname=arial, fontsize=18]
  edge [style=bold, color="#385d8a", arrowhead=none]
  C -> B
  D -> B [weight=0]
  B -> A

  { rank=same; C; D}

  // branch pointers
  edge [arrowhead=normal]
  node [shape=box, style=filled, fillcolor=lightgrey, color=black]
  HEAD [fillcolor="#555555", fontcolor=white]
  master [label="origin/master", fillcolor=lightskyblue]

  { rank=same; HEAD; feature; C}
  feature -> C
  HEAD -> feature

  { rank=same; master; B}
  master -> D

  // change pointers
  change [label="Change 134, Patch Set 1", fillcolor=gold]
  change -> C [weight=0]

  // formatting: Add invisible edge to have D on right side of C,
  // add invisible node to vertically align this graph with graphs
  // on next slides
  node [style=invis]
  edge [style=invis]
  C -> D
  I -> change
}
----

Rebase
------
  git rebase origin/master

[graphviz]
----
digraph {
  // commit graph left
  node [style=bold, shape=circle, color="#385d8a", fontname=arial, fontsize=18]
  edge [style=bold, color="#385d8a", arrowhead=none]
  C -> B [label=" diff", fontcolor=red]
  D -> B [weight=0]
  B -> A

  { rank=same; C; D}

  // branch pointers
  edge [arrowhead=normal]
  node [shape=box, style=filled, fillcolor=lightgrey, color=black]
  HEAD [fillcolor="#555555", fontcolor=white]
  master [label="origin/master", fillcolor=lightskyblue]

  { rank=same; HEAD; feature; C}
  feature -> C
  HEAD -> feature

  { rank=same; master; B}
  master -> D

  // change pointers
  change [label="Change 134, Patch Set 1", fillcolor=gold]
  change -> C [weight=0]

  // formatting: Add invisible edge to have D on right side of C,
  // add invisible node to vertically align this graph with graphs
  // on next slides
  node [style=invis]
  edge [style=invis]
  C -> D
  I -> change

  // the "rebase" arrow
  node [style=invis]
  L -> R [label="rebase origin/master", style=dotted, penwidth=2,
          arrowhead=vee, color=red, fontname=arial, fontsize=30]

  // commit graph right
  node [style=bold, shape=circle, color="#385d8a", fontname=arial, fontsize=18]
  edge [style=bold, color="#385d8a", arrowhead=none]
  A1 [label="A"]
  B1 [label="B"]
  C1 [label="C"]
  D1 [label="D"]
  C2 [label="C'", style=filled, fillcolor=coral1, color=red]
  C2 -> D1 [label=" diff", fontcolor=red]
  C1 -> B1
  D1 -> B1 [weight=0]
  B1 -> A1

  { rank=same; C; C1; D1}

  // branch pointers
  edge [arrowhead=normal]
  node [shape=box, style=filled, fillcolor=lightgrey, color=black]
  HEAD1 [label="HEAD", fillcolor="#555555", fontcolor=white]
  master1 [label="origin/master", fillcolor=lightskyblue]

  { rank=same; HEAD1; feature1; C2}
  feature1 -> C2
  HEAD1 -> feature1

  { rank=same; master1; B1}
  master1 -> D1

  // change pointers
  change1 [label="Change 134, Patch Set 1", fillcolor=gold]
  { rank=same; change1; C1}
  change1 -> C1

  // formatting: Add invisible edge to have D1 on right side of C1
  edge [style=invis]
  C1 -> D1

  // align left, right and the arrow graph
  { rank=same; A; A1; L; R}
}
----

Rebase
------
  git rebase origin/master

[graphviz]
----
digraph {
  // commit graph left
  node [style=bold, shape=circle, color="#385d8a", fontname=arial, fontsize=18]
  edge [style=bold, color="#385d8a", arrowhead=none]
  C -> B [label=" diff", fontcolor=red]
  D -> B [weight=0]
  B -> A

  { rank=same; C; D}

  // branch pointers
  edge [arrowhead=normal]
  node [shape=box, style=filled, fillcolor=lightgrey, color=black]
  HEAD [fillcolor="#555555", fontcolor=white]
  master [label="origin/master", fillcolor=lightskyblue]

  { rank=same; HEAD; feature; C}
  feature -> C
  HEAD -> feature

  { rank=same; master; B}
  master -> D

  // change pointers
  change [label="Change 134, Patch Set 1", fillcolor=gold]
  change -> C [weight=0]

  // formatting: Add invisible edge to have D on right side of C
  edge [style=invis]
  C -> D

  // the "rebase" arrow
  node [style=invis]
  L -> R [label="rebase origin/master", style=dotted, penwidth=2,
          arrowhead=vee, color=red, fontname=arial, fontsize=30]

  // commit graph right
  node [style=bold, shape=circle, color="#385d8a", fontname=arial, fontsize=18]
  edge [style=bold, color="#385d8a", arrowhead=none]
  A1 [label="A"]
  B1 [label="B"]
  C1 [label="C"]
  D1 [label="D"]
  C2 [label="C'", style=filled, fillcolor=coral1, color=red]
  C2 -> D1 [label=" diff", fontcolor=red]
  C1 -> B1
  D1 -> B1 [weight=0]
  B1 -> A1

  { rank=same; C; C1; D1}

  // branch pointers
  edge [arrowhead=normal]
  node [shape=box, style=filled, fillcolor=lightgrey, color=black]
  HEAD1 [label="HEAD", fillcolor="#555555", fontcolor=white]
  master1 [label="origin/master", fillcolor=lightskyblue]

  { rank=same; change; HEAD1; feature1; C2}
  feature1 -> C2
  HEAD1 -> feature1

  { rank=same; master1; B1}
  master1 -> D1

  // change pointers
  change1 [label="Change 134, Patch Set 1", fillcolor=gold]
  { rank=same; change1; C1}
  change1 -> C1
  change2 [label="Change 134, Patch Set 2", fillcolor=gold]
  change2 -> C2

  newPatchSet [label="NEW PATCH SET!!!", style=none, color=none,
                fontcolor=red, fontname=arial, fontsize=30]
  { rank=same; change2; newPatchSet}
  newPatchSet -> change2 [style=invis]

  // formatting: Add invisible edge to have D1 on right side of C1
  edge [style=invis]
  C1 -> D1

  // align left, right and the arrow graph
  { rank=same; A; A1; L; R}
}
----

[role="incremental"]
`Q:` What would happen if the path conflict is resolved by merge?
