blockworx/schema/

encode.rs

//! Hand-rolled KDL emitter for the schema — it walks the [`super::model`] structs
//! (the same ones the parser/walker in [`super::decode`] produce, keeping the two
//! in sync). Output is minimal: fields at their default are omitted, enums render
//! as kebab-case identifiers, and verbatim SVG goes out as a raw string.

use std::fmt::Write as _;

use super::model::{Asset, Block, Comment, Document, Image, ImageData, Label, Pin, Route, Text};

const INDENT: &str = "    ";

pub fn encode(doc: &Document) -> String {
    let mut s = String::new();
    let _ = writeln!(s, "version {}", doc.version);
    if let Some(name) = &doc.name {
        let _ = writeln!(s, "name {}", quote(name));
    }
    let _ = writeln!(s, "top {}", quote(&doc.top));
    for b in &doc.blocks {
        s.push('\n');
        block(&mut s, b);
    }
    // Assets last: the payloads are bulky and the diagram is what a reader (and a
    // diff) wants first.
    for a in &doc.assets {
        s.push('\n');
        asset(&mut s, a);
    }
    s
}

fn block(s: &mut String, b: &Block) {
    let mut head = format!(
        "block {} x={} y={} w={} h={}",
        quote(&b.id),
        b.x,
        b.y,
        b.w,
        b.h
    );
    if let Some(r) = b.role {
        let _ = write!(head, " role={r}");
    }
    if b.locked {
        head.push_str(" locked=true");
    }

    let mut body = String::new();
    if let Some(l) = &b.title {
        label(&mut body, 1, "title", l);
    }
    if let Some(l) = &b.type_label {
        label(&mut body, 1, "type", l);
    }
    for p in &b.pins {
        pin(&mut body, 1, p);
    }
    for r in &b.routes {
        route(&mut body, 1, r);
    }
    for t in &b.texts {
        text(&mut body, 1, t);
    }
    for c in &b.comments {
        comment(&mut body, 1, c);
    }
    for sym in &b.images {
        image(&mut body, 1, sym);
    }
    if let Some(icon) = &b.icon {
        image_node(&mut body, 1, "icon", icon);
    }
    if !b.children.is_empty() {
        indent(&mut body, 1);
        body.push_str("children");
        for cid in &b.children {
            let _ = write!(body, " {}", quote(cid));
        }
        body.push('\n');
    }

    wrap(s, 0, &head, &body);
}

fn label(s: &mut String, level: usize, node: &str, l: &Label) {
    let mut line = node.to_string();
    if !l.name.is_empty() {
        let _ = write!(line, " {}", quote(&l.name));
    }
    if let Some(side) = l.side {
        let _ = write!(line, " side={}", quote(side.as_str()));
    }
    if l.offset != 0.0 {
        let _ = write!(line, " offset={}", fnum(l.offset));
    }
    if l.hidden {
        line.push_str(" hidden=true");
    }
    indent(s, level);
    let _ = writeln!(s, "{line}");
}

fn pin(s: &mut String, level: usize, p: &Pin) {
    // The `type` label and the I/O `kind` are distinct fields; see `PinPort`.
    let mut line = format!("pin {}", quote(&p.id));
    if !p.name.is_empty() {
        let _ = write!(line, " {}", quote(&p.name));
    }
    if let Some(loc) = &p.loc {
        let _ = write!(line, " loc={}", quote(loc));
    }
    if let Some(x) = p.x {
        let _ = write!(line, " x={x}");
    }
    if let Some(y) = p.y {
        let _ = write!(line, " y={y}");
    }
    if let Some(w) = p.w {
        let _ = write!(line, " w={w}");
    }
    if let Some(dir) = p.dir {
        let _ = write!(line, " dir={}", quote(dir.as_str()));
    }
    if !p.type_label.is_empty() {
        let _ = write!(line, " type={}", quote(&p.type_label));
    }
    if !p.tag.is_empty() {
        let _ = write!(line, " tag={}", quote(&p.tag));
    }
    if p.tag_hidden {
        line.push_str(" tag-hidden=true");
    }
    if let Some(a) = p.pin_accent {
        let _ = write!(line, " pin-accent={a}");
    }
    if let Some(a) = p.port_accent {
        let _ = write!(line, " port-accent={a}");
    }
    if let Some(a) = p.port_pin_accent {
        let _ = write!(line, " port-pin-accent={a}");
    }
    if p.fliplr {
        line.push_str(" fliplr=true");
    }
    indent(s, level);
    let _ = writeln!(s, "{line}");
}

fn route(s: &mut String, level: usize, r: &Route) {
    // Anchors are the two positional arguments: `route "b2:p1" "b3:p1"`.
    let mut head = format!("route {} {}", quote(&r.from), quote(&r.to));
    if !r.name.is_empty() {
        let _ = write!(head, " name={}", quote(&r.name));
    }
    if let Some(role) = r.role {
        let _ = write!(head, " role={role}");
    }

    let mut body = String::new();
    for w in &r.waypoints {
        indent(&mut body, level + 1);
        let _ = write!(body, "wp {} {}", w.x, w.y);
        if w.locked {
            body.push_str(" locked=true");
        }
        body.push('\n');
    }
    for at in &r.labels {
        indent(&mut body, level + 1);
        let _ = writeln!(body, "label {}", fnum(*at));
    }
    wrap(s, level, &head, &body);
}

fn text(s: &mut String, level: usize, t: &Text) {
    let mut line = format!("text {}", quote(&t.text));
    if t.x != 0 {
        let _ = write!(line, " x={}", t.x);
    }
    if t.y != 0 {
        let _ = write!(line, " y={}", t.y);
    }
    if let Some(role) = t.role {
        let _ = write!(line, " role={role}");
    }
    indent(s, level);
    let _ = writeln!(s, "{line}");
}

fn comment(s: &mut String, level: usize, c: &Comment) {
    let mut head = format!("comment x={} y={} w={} h={}", c.x, c.y, c.w, c.h);
    if let Some(role) = c.role {
        let _ = write!(head, " role={role}");
    }
    let mut body = String::new();
    if let Some(l) = &c.title {
        label(&mut body, level + 1, "title", l);
    }
    wrap(s, level, &head, &body);
}

fn image(s: &mut String, level: usize, sym: &Image) {
    image_node(s, level, "image", sym);
}

/// Emit an image placement (`image`/`icon`) named `tag`: the id of the asset it
/// draws, then the box it fills.
fn image_node(s: &mut String, level: usize, tag: &str, sym: &Image) {
    indent(s, level);
    let _ = writeln!(
        s,
        "{} {} x={} y={} w={} h={}",
        tag,
        quote(&sym.asset),
        sym.x,
        sym.y,
        sym.w,
        sym.h
    );
}

/// Emit an image asset: its id, and an `svg`/`png` child holding the content.
fn asset(s: &mut String, a: &Asset) {
    let head = format!("asset {}", quote(&a.id));
    let mut body = String::new();
    indent(&mut body, 1);
    match &a.image {
        ImageData::Svg(svg) => {
            let _ = writeln!(body, "svg {}", raw_string(svg));
        }
        ImageData::Png(png) => {
            let _ = writeln!(body, "png {}", quote(png));
        }
    }
    wrap(s, 0, &head, &body);
}

/// Append `head` at `level`; if `body` (already indented one level deeper) is
/// non-empty, wrap it in `{ … }`, otherwise emit `head` as a childless node.
fn wrap(s: &mut String, level: usize, head: &str, body: &str) {
    indent(s, level);
    if body.is_empty() {
        let _ = writeln!(s, "{head}");
    } else {
        let _ = writeln!(s, "{head} {{");
        s.push_str(body);
        indent(s, level);
        s.push_str("}\n");
    }
}

fn indent(s: &mut String, level: usize) {
    for _ in 0..level {
        s.push_str(INDENT);
    }
}

/// Format a float so it always carries a decimal point (so it decodes back as a
/// float, not an integer), while keeping a clean shortest form otherwise.
fn fnum(v: f32) -> String {
    if v.is_finite() && v == v.trunc() {
        format!("{v:.1}")
    } else {
        format!("{v}")
    }
}

fn quote(s: &str) -> String {
    let mut o = String::with_capacity(s.len() + 2);
    o.push('"');
    for c in s.chars() {
        match c {
            '"' => o.push_str("\\\""),
            '\\' => o.push_str("\\\\"),
            '\n' => o.push_str("\\n"),
            '\r' => o.push_str("\\r"),
            '\t' => o.push_str("\\t"),
            _ => o.push(c),
        }
    }
    o.push('"');
    o
}

/// Emit `s` as a KDL v1 raw string `r#"…"#`, widening the `#` fence so the
/// payload (verbatim SVG) can contain any `"#…` run without closing early.
fn raw_string(s: &str) -> String {
    let bytes = s.as_bytes();
    let mut max_hashes = 0usize;
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'"' {
            let mut j = i + 1;
            while j < bytes.len() && bytes[j] == b'#' {
                j += 1;
            }
            max_hashes = max_hashes.max(j - i - 1);
            i = j;
        } else {
            i += 1;
        }
    }
    let fence = "#".repeat(max_hashes + 1);
    format!("r{fence}\"{s}\"{fence}")
}