#moonrockz/diagrams-mermaid

• A ; ends a statement, as a line break does. One exception comes from the grammar: an autonumber number must have a space or a line break after it, so autonumber 10; is an error in Mermaid and here, but autonumber 10 ; is not.
• # starts a comment, also in a message text, but an entity code such as #9829; is text.
• %% at the start of a statement starts a comment, and %%{...}%% is a directive.
• Keywords do not depend on letter case.

#Read, print and convert

///|
test {
  let source = "sequenceDiagram\n%% the client calls the API\nparticipant  Client\nClient ->> API :GET /forecast\n"
  let r = @mermaid.read(source)
  assert_eq(r.tree.text(), source)
  assert_eq(r.diagnostics.length(), 0)
  let ast = r.ast.unwrap()
  assert_eq(
    @mermaid.print(ast),
    "sequenceDiagram\n  participant Client\n  Client->>API: GET /forecast\n",
  )
  let model = @mermaid.to_sequence(ast).sequence
  assert_eq(model.participants.length(), 2)
}

#Canonical printing

• The front matter comes first, then each %%{...}%% directive on its own line, then sequenceDiagram.
• Each statement is on its own line. Statements have two spaces of indentation for each level: one under the header, and one more in each frame and box.
• Keywords are in lower case, except sequenceDiagram, accTitle and accDescr. title: text becomes title text.
• A message is the sender, () if it has one before the arrow, the arrow as written, + or -, () if it has one after the arrow, the receiver, :, and a space and the text if the text is not empty. Notes and link, links, properties and details statements use the same : text form.
• Two note participants are joined by , with no spaces.
• A participant configuration is written @{ and its text and }.
• A - after an arrow that ends with -, such as /|-, has a space before it, because /|-- is another arrow.
• A description with a line break (\n or \r) uses accDescr { ... } with its lines as written. Any other description uses accDescr: text.
• Comments are not printed, because the AST does not keep them.

///|
test {
  let source = "sequenceDiagram\nALT Is sick\n  B ->>- A : Not so good\nELSE is well\nNote Over A , B: fine\nEND\n"
  let printed = @mermaid.print(@mermaid.read(source).ast.unwrap())
  assert_eq(
    printed, "sequenceDiagram\n  alt Is sick\n    B->>-A: Not so good\n  else is well\n    note over A,B: fine\n  end\n",
  )
  assert_eq(@mermaid.read(printed).ast, @mermaid.read(source).ast)
}

#Diagnostics

///|
test {
  let r = @mermaid.read("sequenceDiagram\nA->>B: hi\nfrobnicate A\n")
  let d = r.diagnostics[0]
  assert_eq(d.code, "mermaid/unknown-statement")
  assert_eq(d.span.unwrap().start.line, 3)
  assert_eq(r.ast.unwrap().statements.length(), 1)
}

///|
test {
  assert_eq(@mermaid.diagnostic_codes.iter().to_array(), [
    "mermaid/missing-header", "mermaid/unexpected-header", "mermaid/unknown-statement",
    "mermaid/missing-message-text", "mermaid/invalid-message", "mermaid/invalid-participant",
    "mermaid/invalid-note", "mermaid/invalid-autonumber", "mermaid/invalid-link",
    "mermaid/invalid-title", "mermaid/missing-end", "mermaid/unexpected-end", "mermaid/misplaced-section",
    "mermaid/invalid-in-box", "mermaid/unclosed-directive", "mermaid/unclosed-description",
  ])
}

#Sequence model and semantics

#Links

///|
test {
  let source = "sequenceDiagram\nparticipant W\nlink W: shape @ smithy:example.weather/Weather\nC->>W: example.weather/GetForecast\n"
  let converted = @mermaid.to_sequence(@mermaid.read(source).ast.unwrap())
  assert_eq(converted.diagnostics.length(), 0)
  assert_eq(
    converted.sequence.participant("W").unwrap().link.unwrap().target,
    "example.weather#Weather",
  )
}

#Render as SVG

///|
test {
  let r = @mermaid.render_svg("sequenceDiagram\nClient->>API: GET /forecast\n")
  assert_eq(r.media_type, "image/svg+xml")
  assert_true(
    r.output.unwrap().has_prefix("<svg xmlns=\"http://www.w3.org/2000/svg\""),
  )
}

#Native swimlane API

///|
test "read print and render a native two-lane swimlane" {
  let source = "swimlane-beta LR\nsubgraph Customer\nA([Request])\nend\nsubgraph Support\nB{Review}\nend\nA handoff@--> B\n"
  let result = @mermaid.read_diagram(source)
  assert_eq(result.tree.text(), source)
  assert_eq(result.diagnostics, [])
  guard result.ast is Some(parsed) else { fail("missing AST") }
  let printed = @mermaid.print_diagram(parsed)
  assert_eq(@mermaid.read_diagram(printed.output.unwrap()).ast, Some(parsed))
  guard parsed is Swimlane(ast) else { fail("wrong kind") }
  let converted = @mermaid.to_swimlane(ast)
  assert_eq(converted.diagnostics, [])
  let view = converted.swimlane.unwrap()
  assert_eq(view.lanes.length(), 2)
  assert_eq(view.nodes[0].lane, Some("Customer"))
  assert_eq(view.nodes[1].lane, Some("Support"))
  assert_eq(view.connections[0].id, "handoff")
  let rendered = @mermaid.render_svg(source)
  assert_eq(rendered.media_type, "image/svg+xml")
  assert_true(rendered.output is Some(_))
}

#Normalization and retained data

///|
test "grouped expansion retains one native explicit ID and every occurrence" {
  let read = @mermaid.read_diagram("swimlane-beta\nA & B e@--> C & D\n")
  guard read.ast is Some(Swimlane(ast)) else { fail("missing AST") }
  let view = @mermaid.to_swimlane(ast).swimlane.unwrap()
  assert_eq(view.nodes.length(), 4)
  assert_eq(view.connections.length(), 4)
  assert_eq(view.connections.iter().filter(edge => edge.id == "e").count(), 1)
}

#Swimlane diagnostics and limits

///|
test "documented native diagnostic inventories match exported code" {
  assert_eq(@mermaid.swimlane_diagnostic_codes, [
    "swimlane/source-limit", "swimlane/work-limit", "swimlane/depth-limit", "swimlane/unsupported-header",
    "swimlane/directive", "swimlane/unexpected-end", "swimlane/syntax", "swimlane/missing-end",
  ])
  assert_eq(@mermaid.swimlane_conversion_diagnostic_codes, [
    "swimlane/work-limit", "swimlane/node-limit", "swimlane/edge-limit", "swimlane/depth-limit",
    "swimlane/direction", "swimlane/ownership-cycle", "swimlane/ownership", "swimlane/invalid-ast",
    "swimlane/presentation-metadata",
  ])
}

#Native ZenUML interactions

///|
test {
  let source = "zenuml\n@Actor User\n@PostgreSQL Store\nUser->Store: query\n"
  let parsed = @mermaid.read_diagram(source)
  assert_eq(parsed.tree.text(), source)
  guard parsed.ast is Some(@mermaid.ParsedDiagram::Zenuml(ast)) else {
    fail("ZenUML expected")
  }
  let converted = @mermaid.to_zenuml_sequence(ast)
  assert_eq(converted.sequence.unwrap().participants.length(), 2)
  assert_eq(
    converted.sequence.unwrap().participants[0].icon.unwrap().key,
    "actor",
  )
  assert_true(@mermaid.render_svg(source).output is Some(_))
}

#Native architecture diagrams

#Native flowcharts

///|
test "native flowchart read print convert and render" {
  let source = "graph LR\nsubgraph Checks\nA[Read] --> B{Valid?}\nend\nB -->|yes| C[Save]\nB -->|no| A\n"
  let read = @mermaid.read_diagram(source)
  assert_eq(read.tree.text(), source)
  guard read.ast is Some(Flowchart(ast)) else { fail("missing flowchart") }
  let printed = @mermaid.print_diagram(Flowchart(ast)).output.unwrap()
  assert_eq(@mermaid.read_diagram(printed).ast, read.ast)
  let model = @mermaid.to_flowchart(ast).flowchart.unwrap()
  assert_eq(model.lanes.length(), 0)
  assert_eq(model.groups.length(), 1)
  assert_eq(model.connections.length(), 3)
  assert_true(@mermaid.render_svg(source).output != None)
}