added test for sync edge cases

fixes #20

docs/sequences.typ

@@ -22,6 +22,7 @@
 /// - destroy-src (bool): If true, destroy the source lifeline and participant
 /// - lifeline-style (auto, dict): Optional styling options for lifeline rectangles (see CeTZ documentation for more information on all possible values)
 /// - slant (none, int): Optional slant of the arrow
+/// - outer-lifeline-connect (bool): If true, enables legacy anchoring, making sequences connect to the leftmost lifeline when arriving from the left side. If false, all connections are made with the latest/rightmost lifeline
 /// -> array
 #let _seq(
   p1,
@@ -40,7 +41,8 @@
   disable-src: false,
   destroy-src: false,
   lifeline-style: auto,
-  slant: none
+  slant: none,
+  outer-lifeline-connect: false
 ) = {}
 
 /// Creates a return sequence

src/core/draw/sequence.typ

@@ -137,13 +137,19 @@
   end-info.ll-lvl = ctx.lifelines.at(i2).level * LIFELINE-W / 2
 
   // Compute left/right position at start/end
-  start-info.insert("lx", start-info.x)
-  if start-info.ll-lvl != 0 { start-info.lx -= LIFELINE-W / 2 }
-  end-info.insert("lx", end-info.x)
-  if end-info.ll-lvl != 0 { end-info.lx -= LIFELINE-W / 2 }
-
   start-info.insert("rx", start-info.x + start-info.ll-lvl)
   end-info.insert("rx", end-info.x + end-info.ll-lvl)
+  let start-lx = start-info.x
+  let end-lx = end-info.x
+  if seq.outer-lifeline-connect {
+    if start-info.ll-lvl != 0 {start-lx -= LIFELINE-W / 2}
+    if end-info.ll-lvl != 0 {end-lx -= LIFELINE-W / 2}
+  } else {
+    if start-info.ll-lvl != 0 {start-lx = start-info.rx - LIFELINE-W}
+    if end-info.ll-lvl != 0 {end-lx = end-info.rx - LIFELINE-W}
+  }
+  start-info.insert("lx", start-lx)
+  end-info.insert("lx", end-lx)
 
   // Choose correct points to link
   let x1 = start-info.rx
@@ -388,6 +394,11 @@
   set-ctx(c => {
     c.y = end-info.y
     c.lifelines = ctx.lifelines
+    c.last-drawn = (
+      type: "seq",
+      start-info: start-info,
+      end-info: end-info
+    )
     return c
   })
 })

src/core/draw/sync.typ

@@ -1,32 +1,66 @@
 #import "/src/core/utils.typ": get-ctx, is-elmt, set-ctx
+#import "/src/cetz.typ": draw
 
 #let render(sync) = get-ctx(ctx => {
   set-ctx(c => {
-    c.sync-ys = ()
+    c.sync = (
+      ctx: ctx,
+      bottoms: (),
+      starts: (),
+      start-y: ctx.y,
+      align-y: ctx.y
+    )
+    c.in-sync = true
     return c
   })
+})
 
+#let in-sync-render(elmt) = {
+  set-ctx(c => {
+    c.y = c.sync.start-y
+    return c
+  })
+  draw.hide({
+    (elmt.draw)(elmt)
+  })
+  set-ctx(c => {
+    c.sync.starts.push(c.last-drawn.start-info.y)
+    c.sync.bottoms.push(c.y)
+    return c
+  })
+}
+
+#let render-end(sync) = get-ctx(ctx => {
   for e in sync.elmts {
     assert(is-elmt(e), message: "Sync element can only contain chronos elements, found " + repr(e))
     assert(
       e.type == "seq",
       message: "Sync element can only contain sequences, found '" + e.type + "'"
     )
-
-    set-ctx(c => {
-      c.y = ctx.y
-      return c
-    })
-    (e.draw)(e)
-    set-ctx(c => {
-      c.sync-ys.push(c.y)
-      return c
-    })
   }
 
   set-ctx(c => {
-    c.y = calc.min(..c.sync-ys)
-    c.remove("sync-ys")
+    let new-sync = c.sync
+    if new-sync.starts.len() != 0 {
+      new-sync.align-y = calc.min(..new-sync.starts)
+    }
+    new-sync.remove("ctx")
+    return c.sync.ctx + (sync: new-sync)
+  })
+
+  for (i, e) in sync.elmts.enumerate() {
+    set-ctx(c => {
+      let dy = c.sync.starts.at(i) - c.sync.start-y
+      c.y = c.sync.align-y - dy
+      return c
+    })
+    (e.draw)(e)
+  }
+
+  set-ctx(c => {
+    let heights = c.sync.starts.zip(c.sync.bottoms).map(((s, b)) => b - s)
+    c.y = c.sync.align-y + calc.min(..heights)
+    c.remove("sync")
     return c
   })
 })

src/core/renderer.typ

@@ -2,6 +2,7 @@
 
 #import "draw/note.typ": get-box as get-note-box, get-size as get-note-size
 #import "draw/participant.typ"
+#import "draw/sync.typ": in-sync-render
 #import "utils.typ": *
 #import "/src/consts.typ": *
 
@@ -15,22 +16,6 @@
   })
 }
 
-#let unwrap-syncs(elements) = {
-  let i = 0
-  while i < elements.len() {
-    let elmt = elements.at(i)
-    if elmt.type == "sync" {
-      elements = (
-        elements.slice(0, i + 1) +
-        elmt.elmts +
-        elements.slice(i + 1)
-      )
-    }
-    i += 1
-  }
-  return elements
-}
-
 #let seq-update-lifelines(participants, pars-i, seq) = {
   let participants = participants
   let com = if seq.comment == none {""} else {seq.comment}
@@ -308,7 +293,6 @@
 
 #let compute-columns-width(participants, elements, pars-i) = {
   elements = elements.filter(is-elmt)
-  elements = unwrap-syncs(elements)
 
   let cells
   (participants, elements, cells) = compute-max-lifeline-levels(participants, elements, pars-i)
@@ -334,7 +318,8 @@
     lifelines: participants.map(_ => (
       level: 0,
       lines: ()
-    ))
+    )),
+    in-sync: false
   )
   chronos-ctx.insert(
     "widths",
@@ -393,7 +378,13 @@
     if not is-elmt(elmt) {
       (elmt,)
     } else if "draw" in elmt and elmt.type != "par" {
-      (elmt.draw)(elmt)
+      get-ctx(ctx => {
+        if ctx.in-sync and elmt.type != "sync-end" {
+          in-sync-render(elmt)
+        } else {
+          (elmt.draw)(elmt)
+        }
+      })
     }
   }
 

src/core/setup.typ

@@ -1,4 +1,5 @@
 #import "draw/group.typ": render-end as grp-render-end
+#import "draw/sync.typ": render-end as sync-render-end
 #import "utils.typ": get-group-span, is-elmt
 #import "/src/participant.typ": _exists as par-exists, _par
 #import "/src/sequence.typ": _seq
@@ -18,6 +19,24 @@
   )
 }
 
+#let flatten-sync(elmts, i) = {
+  let sync = elmts.at(i)
+  elmts.at(i) = sync
+  let start = sync
+  start.remove("elmts")
+  return (
+    elmts.slice(0, i) +
+    (start,) +
+    sync.elmts +
+    ((
+      type: "sync-end",
+      draw: sync-render-end,
+      elmts: sync.elmts
+    ),) +
+    elmts.slice(i + 1)
+  )
+}
+
 #let update-group-children(elmts, i) = {
   let elmts = elmts
   let group-end = elmts.at(i)
@@ -58,6 +77,9 @@
 
     if elmt.type == "grp" {
       elmts = flatten-group(elmts, i)
+    
+    } else if elmt.type == "sync" {
+      elmts = flatten-sync(elmts, i)
 
     } else if elmt.type == "seq" {
       if elmt.enable-dst {

src/sequence.typ

@@ -17,7 +17,8 @@
   disable-src: false,
   destroy-src: false,
   lifeline-style: auto,
-  slant: none
+  slant: none,
+  outer-lifeline-connect: false
 ) = {
   return ((
     type: "seq",
@@ -39,6 +40,7 @@
     destroy-src: destroy-src,
     lifeline-style: lifeline-style,
     slant: slant,
+    outer-lifeline-connect: outer-lifeline-connect,
     linked-notes: ()
   ),)
 }

tests/sequence/outer-lifeline/.gitignore

@@ -0,0 +1,4 @@
+# generated by tytanic, do not edit
+
+diff/**
+out/**

tests/sequence/outer-lifeline/test.typ

@@ -0,0 +1,29 @@
+#set page(width: auto, height: auto)
+#import "/src/lib.typ": *
+
+#let make-diagram(_seq) = {
+  diagram({
+    _par("a")
+    _par("b")
+    _par("c")
+    _seq("a", "b")
+    _seq("c", "b")
+    _seq("a", "b", enable-dst: true)
+    _seq("a", "b")
+    _seq("c", "b")
+    _seq("a", "b", enable-dst: true)
+    _seq("a", "b")
+    _seq("c", "b")
+    _seq("a", "b", enable-dst: true)
+    _seq("a", "b")
+    _seq("c", "b")
+
+    _evt("b", "disable")
+    _evt("b", "disable")
+    _evt("b", "disable")
+  })
+}
+
+#make-diagram(_seq)
+#pagebreak()
+#make-diagram(_seq.with(outer-lifeline-connect: true))

tests/sequence/sync/.gitignore

@@ -0,0 +1,4 @@
+# generated by tytanic, do not edit
+
+diff/**
+out/**

tests/sequence/sync/test.typ

@@ -0,0 +1,47 @@
+#set page(width: auto, height: auto)
+#import "/src/lib.typ": *
+
+#diagram({
+  _par("a")
+  _par("b")
+  _par("c")
+  _sync({
+    _seq("b", "a")
+    _seq("b", "c")
+  })
+  _gap()
+  _sync({
+    _seq("b", "a", comment: [Comment])
+    _seq("b", "c")
+  })
+  _gap()
+  _sync({
+    _seq("b", "a")
+    _seq("b", "c", comment: [Comment])
+  })
+  _gap()
+  _sync({
+    _seq("b", "a", comment: [Two\ lines])
+    _seq("b", "c", comment: [Comment])
+  })
+
+  _sync({
+    _seq("b", "a")
+    _seq("b", "c", slant: 10)
+  })
+
+  _sync({
+    _seq("b", "a")
+    _seq("b", "b")
+  })
+})
+
+#pagebreak()
+
+#diagram({
+  _sync({
+    _seq("a", "b", comment: [Abcdefgh])
+    _seq("b", "c", comment: [Foo\ bar], slant: 10)
+    _seq("c", "c", slant: 20)
+  })
+})