#moonrockz/diagrams-svg

#Render a sequence

///|
test {
  let s = @sequence.Sequence::new(
    [@sequence.Participant::new("Client"), @sequence.Participant::new("API")],
    [Message(@sequence.Message::new("Client", "API", "GET /forecast"))],
  )
  let r = @render.Renderer::render(@svg.SvgRenderer::new(), Sequence(s))
  assert_eq(r.media_type, "image/svg+xml")
  assert_eq(r.diagnostics.length(), 0)
  let svg = r.output.unwrap()
  assert_true(svg.contains("@media (prefers-color-scheme: light)"))
  assert_true(svg.contains("data-id=\"Client\""))
}

#Fixed output and render properties

///|
test {
  let s = @sequence.Sequence::new([], [], title="Login flow")
  let svg = @svg.render_sequence(s, mode=Fixed(Light))
  assert_false(svg.contains("<style"))
  assert_false(svg.contains("var("))
  assert_true(svg.contains("fill=\"#f4f5f7\""))
}

#Renderer verification

#Layout geometry

#Legibility

///|
test {
  let s = @sequence.Sequence::new(
    [@sequence.Participant::new("A"), @sequence.Participant::new("B")],
    [Message(@sequence.Message::new("A", "B", "hello"))],
  )
  let g = @layout.layout(s)
  let theme = @theme.Theme::classic()
  assert_eq(@layout.check(g, theme.dark), [])
  assert_eq(@layout.check(g, theme.light), [])
}

#BPMN processes and collaborations

#Notice

#Motion scenes

///|
test "canonical scene SVG equals the ordinary static renderer" {
  let sequence = @sequence.Sequence::new(
    [@sequence.Participant::new("A"), @sequence.Participant::new("B")],
    [Message(@sequence.Message::new("A", "B", "hello"))],
  )
  let renderer = @svg.SvgRenderer::new()
  let scene = renderer.scene(Sequence(sequence)).scene.unwrap()
  assert_eq(scene.canonical_svg, @svg.render_sequence(sequence))
  assert_false(scene.canonical_svg.contains("data-motion-paths"))
  assert_true(scene.display_svg.contains("data-motion-paths"))
  assert_eq(scene.paths.length(), 1)
}

#Native Mermaid swimlanes

///|
test "swimlane SVG and scene share one actual handoff path" {
  let view = @swimlane.Swimlane::new(
    "Request",
    [
      @swimlane.Node::new("Ask", lane="Customer", shape="stadium"),
      @swimlane.Node::new("Review", lane="Support", shape="diamond"),
    ],
    [@swimlane.Connection::new("handoff", "Ask", "Review", label="request")],
    lanes=[@swimlane.Lane::new("Customer"), @swimlane.Lane::new("Support")],
    direction=LR,
  )
  let renderer = @svg.SvgRenderer::new(id_prefix="request")
  let result = renderer.render(Swimlane(view))
  assert_eq(result.diagnostics, [])
  let scene = renderer.scene(Swimlane(view)).scene.unwrap()
  assert_eq(scene.canonical_svg, result.output.unwrap())
  assert_eq(scene.paths.length(), 1)
  assert_true(scene.canonical_svg.contains("d=\"" + scene.paths[0].path + "\""))
}

#Regex and EBNF railroads

///|
test "a regex railroad has one path for each topology connector" {
  let model = @regex.Regex::new("digits", "s", [
    @regex.Node::new("s", Sequence(["a", "r"])),
    @regex.Node::new("a", Anchor(LineStart)),
    @regex.Node::new("r", Repeat(@regex.Bounds::new(1), "d")),
    @regex.Node::new("d", Class(Shorthand('d'))),
  ])
  let result = @svg.render_regex(model, mode=Fixed(Light))
  assert_eq(result.diagnostics, [])
  let svg = result.output.unwrap()
  let topology = @railroad_trace.Topology::regex(model).topology.unwrap()
  assert_eq(
    svg.split("data-connector=\"").count() - 1,
    topology.connectors.length(),
  )
}

#Static trace highlights

///|
test "a failure terminal can be shown without its prefix" {
  let model = @regex.Regex::new("ab", "s", [
    @regex.Node::new("s", Sequence(["a", "b"])),
    @regex.Node::new("a", Literal("a")),
    @regex.Node::new("b", Class(Shorthand('d'))),
  ])
  let request = @railroad_trace.TraceRequest::regex(model, "ax")
  let topology = request.topology().topology.unwrap()
  let start = topology.connector_of("ab", Start).unwrap()
  let trace = @railroad_trace.Trace::new(request, "example", [
    @railroad_trace.Attempt::new(
      "a0",
      NotMatched,
      [
        Traverse(start.id, false),
        Visit("a", Some(@railroad_trace.InputSpan::new(0, 1))),
      ],
      failure=@railroad_trace.FailurePoint::new(Terminal("b"), position=1),
    ),
  ])
  let only_failure = @svg.TraceHighlight::new(
    trace,
    matched=@svg.ChannelStyle::hidden(),
    not_matched=@svg.ChannelStyle::hidden(),
  )
  let svg = @svg.render_regex(model, trace=only_failure).output.unwrap()
  assert_true(svg.contains("rr-trace-failure"))
  assert_false(svg.contains("rr-trace-path"))
  let plain = @svg.render_regex(model).output.unwrap()
  assert_false(plain.contains("rr-trace"))
}

#Structured data

///|
test "an inline scalar row has no connector" {
  let tree = @data_tree.DataTree::new("order", "root", [
    @data_tree.Node::object("root", [
      @data_tree.Member::named("m0", "id", "v0"),
      @data_tree.Member::named("m1", "tags", "v1"),
    ]),
    @data_tree.Node::new("v0", Number("12345678901234567890")),
    @data_tree.Node::array("v1", [@data_tree.Member::index("e0", 0, "v2")]),
    @data_tree.Node::new("v2", Text("gift")),
  ])
  let svg = @svg.render_data_tree(tree, mode=Fixed(Dark)).output.unwrap()
  assert_true(svg.contains("12345678901234567890"))
  assert_eq(svg.split("class=\"data-connector\"").count() - 1, 1)
}

#Connector styles and final geometry

///|
test "typed styles expose the same immutable final geometry as SVG" {
  let view = @flowchart.Flowchart::new(
    "connectors",
    [
      @flowchart.Node::new("a", label="Request"),
      @flowchart.Node::new("b", label="Done"),
    ],
    [@flowchart.Connection::new("ab", "a", "b")],
  )
  let renderer = @svg.SvgRenderer::new(
    connectors=@svg.ConnectorOptions::new(
      style=Curved,
      crossing=Bridge,
      minimum_approach=32.0,
    ),
  )
  let model = @render.Diagram::Flowchart(view)
  let output = renderer.render(model).output.unwrap()
  let paths = @svg.inspect_connectors(output)
  assert_eq(paths.length(), 1)
  assert_eq(paths[0].id, "ab")
  assert_eq(paths[0].source, "a")
  assert_eq(paths[0].target, "b")
  assert_eq(paths, renderer.connector_geometry(model).paths)
}