svg.rs

use crate::font::{self, Font};
use crate::label::Placed;
use crate::layout::{Figure, PlacedAtom};
use crate::outline;
use crate::style::Style;
use crate::text::{escape, number};


#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Shape {
    Outline,
    Text,
}


pub fn render(figure: &Figure, font: &Font, style: &Style, shape: Shape, label: &str) -> String {
    let extent = figure.extent.grow(style.margin);
    let width = (extent.right - extent.left).max(style.margin * 2.0);
    let height = (extent.bottom - extent.top).max(style.margin * 2.0);
    let mut out = String::new();

    out.push_str("<svg xmlns=\"http://www.w3.org/2000/svg\"");
    out.push_str(&format!(" width=\"{}em\" height=\"{}em\"", number(width), number(height)));
    out.push_str(&format!(
        " viewBox=\"{} {} {} {}\"",
        number(extent.left),
        number(extent.top),
        number(width),
        number(height)
    ));
    // An inline SVG sits on the baseline by its bottom edge
    let baseline = font::cap_height(font) / 2.0;
    let drop = extent.bottom - baseline;
    out.push_str(&format!(" style=\"vertical-align:{}em\"", number(-drop)));
    out.push_str(&format!(" role=\"img\" aria-label=\"{}\">", escape(label)));

    push_bond(&mut out, figure, style);
    push_wedge(&mut out, figure, style);
    push_circle(&mut out, figure, style);

    match shape {
        Shape::Outline => push_outline(&mut out, figure, font, style),
        Shape::Text => push_text(&mut out, figure, font),
    }

    push_fallback(&mut out, figure);

    out.push_str("</svg>");
    out
}


fn every_atom(figure: &Figure) -> impl Iterator<Item = &PlacedAtom> {
    figure.atom.iter().chain(figure.name.iter())
}


fn push_outline(out: &mut String, figure: &Figure, font: &Font, style: &Style) {
    let unit = font::units_per_em(font);
    let mut data = String::new();

    for atom in every_atom(figure) {
        for placed in &atom.label.placed {
            let Some(glyph) = placed.glyph else {
                continue;
            };
            let drawn = font::outline_of(font, glyph);

            if drawn.segment.is_empty() {
                continue;
            }

            let scale = placed.size / unit;
            let x = atom.origin_x + placed.x;
            let y = atom.origin_y + placed.y;
            data.push_str(&outline::path_data(&drawn, scale, x, y));
        }
    }

    if data.is_empty() {
        return;
    }

    out.push_str("<path fill=\"currentColor\"");

    if style.darken > 0.0 {
        let weight = number(style.darken);
        out.push_str(&format!(
            " stroke=\"currentColor\" stroke-width=\"{weight}\" stroke-linejoin=\"round\""
        ));
    }

    out.push_str(&format!(" d=\"{data}\"/>"));
}


fn push_text(out: &mut String, figure: &Figure, font: &Font) {
    let family = escape(font::family(font));

    for atom in every_atom(figure) {
        let mut start = 0;
        let placed = &atom.label.placed;

        while start < placed.len() {
            if placed[start].glyph.is_none() {
                start += 1;

                continue;
            }

            let mut end = start + 1;

            while end < placed.len() && continues(&placed[start], &placed[end]) {
                end += 1;
            }

            push_run(out, atom, &placed[start..end], &family);
            start = end;
        }
    }
}


fn continues(first: &Placed, next: &Placed) -> bool {
    next.glyph.is_some() && next.size == first.size && next.y == first.y
}


fn push_run(out: &mut String, atom: &PlacedAtom, run: &[Placed], family: &str) {
    let mut horizontal = String::new();
    let mut body = String::new();

    for placed in run {
        if !horizontal.is_empty() {
            horizontal.push(' ');
        }

        horizontal.push_str(&number(atom.origin_x + placed.x));
        body.push(placed.character);
    }

    out.push_str(&format!(
        "<text x=\"{horizontal}\" y=\"{}\" font-size=\"{}\" font-family=\"{family}\" \
         fill=\"currentColor\">{}</text>",
        number(atom.origin_y + run[0].y),
        number(run[0].size),
        escape(&body)
    ));
}


fn push_bond(out: &mut String, figure: &Figure, style: &Style) {
    if figure.line.is_empty() {
        return;
    }

    let mut data = String::new();

    for line in &figure.line {
        data.push('M');
        data.push_str(&number(line.x1));
        data.push(' ');
        data.push_str(&number(line.y1));
        data.push('L');
        data.push_str(&number(line.x2));
        data.push(' ');
        data.push_str(&number(line.y2));
    }

    out.push_str(&format!(
        "<path fill=\"none\" stroke=\"currentColor\" stroke-width=\"{}\" \
         stroke-linecap=\"round\" d=\"{data}\"/>",
        number(style.line_width)
    ));
}


fn push_wedge(out: &mut String, figure: &Figure, style: &Style) {
    for filled in [true, false] {
        let mut data = String::new();

        for wedge in figure.wedge.iter().filter(|one| one.filled == filled) {
            data.push('M');
            data.push_str(&spot(wedge.tip));
            data.push('L');
            data.push_str(&spot(wedge.base[0]));
            data.push('L');
            data.push_str(&spot(wedge.base[1]));
            data.push('Z');
        }

        if data.is_empty() {
            continue;
        }

        if filled {
            out.push_str(&format!("<path fill=\"currentColor\" d=\"{data}\"/>"));

        } else {
            out.push_str(&format!(
                "<path fill=\"none\" stroke=\"currentColor\" stroke-width=\"{}\" \
                 stroke-linejoin=\"round\" d=\"{data}\"/>",
                number(style.line_width)
            ));
        }
    }
}


fn push_circle(out: &mut String, figure: &Figure, style: &Style) {
    for circle in &figure.circle {
        out.push_str(&format!(
            "<circle cx=\"{}\" cy=\"{}\" r=\"{}\" fill=\"none\" stroke=\"currentColor\" \
             stroke-width=\"{}\"/>",
            number(circle.x),
            number(circle.y),
            number(circle.radius),
            number(style.line_width)
        ));
    }
}


fn spot(point: (f64, f64)) -> String {
    format!("{} {}", number(point.0), number(point.1))
}


fn push_fallback(out: &mut String, figure: &Figure) {
    for atom in every_atom(figure) {
        for placed in &atom.label.placed {
            if placed.glyph.is_some() {
                continue;
            }

            let x = number(atom.origin_x + placed.x);
            let y = number(atom.origin_y + placed.y);
            let size = number(placed.size);
            let text = escape(&placed.character.to_string());
            out.push_str(&format!(
                "<text x=\"{x}\" y=\"{y}\" font-size=\"{size}\" \
                 font-family=\"{}\" fill=\"currentColor\">{text}</text>",
                font::FALLBACK
            ));
        }
    }
}


#[cfg(test)]
mod tests {
    use super::*;
    use crate::font::sample;
    use crate::layout::layout;
    use crate::parse::parse;

    fn draw(source: &str) -> String {
        let font = sample();
        let style = Style::default();
        let figure = layout(&parse(source).unwrap(), &font, &style).unwrap();

        render(&figure, &font, &style, Shape::Outline, source)
    }

    fn write(source: &str) -> String {
        let font = sample();
        let style = Style::default();
        let figure = layout(&parse(source).unwrap(), &font, &style).unwrap();

        render(&figure, &font, &style, Shape::Text, source)
    }

    #[test]
    fn writes_one_svg_element() {
        let found = draw("H-O-H");
        assert!(found.starts_with("<svg xmlns=\"http://www.w3.org/2000/svg\""));
        assert!(found.ends_with("</svg>"));
        assert_eq!(found.matches("<svg").count(), 1);
    }

    #[test]
    fn the_size_is_written_in_em() {
        let found = draw("H-O-H");
        assert!(found.contains("em\" height=\""));
        assert!(found.contains("viewBox=\""));
    }

    #[test]
    fn the_figure_sits_on_the_baseline_of_the_text_around_it() {
        let found = draw("H-O-H");
        let at = found.find("vertical-align:").expect("no vertical-align");
        let rest = &found[at + "vertical-align:".len()..];
        let value: f64 = rest[..rest.find("em").unwrap()].parse().unwrap();
        assert!(value < 0.0, "the figure is not lowered");
        assert!(value > -1.0, "lowered too far: {value}");
    }

    #[test]
    fn a_taller_figure_hangs_lower() {
        let flat = draw("H-H");
        let tall = draw("H-[:-90]H");
        let of = |markup: &str| {
            let at = markup.find("vertical-align:").unwrap() + "vertical-align:".len();
            let rest = &markup[at..];
            rest[..rest.find("em").unwrap()].parse::<f64>().unwrap()
        };
        assert!(of(&tall) < of(&flat), "a taller figure is not lowered more");
    }

    #[test]
    fn the_glyphs_come_out_as_outlines() {
        let found = draw("H-O-H");
        assert!(found.contains("<path fill=\"currentColor\""));
        assert!(found.contains("C"), "no curve command");
    }

    #[test]
    fn the_bonds_come_out_as_one_stroked_path() {
        let found = draw("H-O-H");
        assert_eq!(found.matches("stroke-linecap=\"round\"").count(), 1);
        assert_eq!(found.matches("fill=\"none\"").count(), 1);
    }

    #[test]
    fn a_molecule_with_no_bond_still_draws() {
        let found = draw("H_2O");
        assert!(found.contains("<path fill=\"currentColor\""));
        assert!(!found.contains("fill=\"none\""));
    }

    #[test]
    fn the_label_becomes_the_alternative_text() {
        assert!(draw("O=C=O").contains("aria-label=\"O=C=O\""));
    }

    #[test]
    fn markup_in_the_label_is_escaped() {
        let font = sample();
        let style = Style::default();
        let figure = layout(&parse("A-B").unwrap(), &font, &style).unwrap();
        let found = render(&figure, &font, &style, Shape::Outline, "<a>&");
        assert!(found.contains("aria-label=\"&lt;a&gt;&amp;\""));
    }

    #[test]
    fn a_filled_wedge_is_a_closed_path() {
        let found = draw("C>H");
        let at = found.find("<path fill=\"currentColor\" d=\"M").expect("no triangle");
        let data = &found[at..found[at..].find("\"/>").unwrap() + at];
        assert_eq!(data.matches('L').count(), 2);
        assert_eq!(data.matches('Z').count(), 1);
    }

    #[test]
    fn a_hollow_wedge_is_stroked_instead() {
        let found = draw("C>|H");
        assert!(found.contains("stroke-linejoin=\"round\" d=\"M"));
        assert!(found.contains('Z'));
    }

    #[test]
    fn an_aromatic_ring_writes_a_circle() {
        let found = draw("**6(------)");
        assert_eq!(found.matches("<circle").count(), 1);
        assert!(found.contains("fill=\"none\" stroke=\"currentColor\""));
    }

    #[test]
    fn a_plain_ring_writes_no_circle() {
        assert!(!draw("*6(------)").contains("<circle"));
    }

    #[test]
    fn the_bonds_are_written_before_the_letters() {
        let found = draw("H-O-H");
        let bond = found.find("fill=\"none\"").unwrap();
        let glyph = found.find("<path fill=\"currentColor\"").unwrap();
        assert!(bond < glyph, "letters are hidden under bonds");
    }

    #[test]
    fn the_text_shape_writes_letters_instead_of_outlines() {
        let found = write("H-O-H");
        assert_eq!(found.matches("<text").count(), 3);
        assert!(!found.contains("<path fill=\"currentColor\""), "outlines are left");
        assert!(found.contains("font-family=\"Latin Modern Math\""));
        assert!(found.contains("fill=\"none\""), "bonds are missing");
    }

    #[test]
    fn letters_of_the_same_size_and_height_share_one_text() {
        let found = write("CH_3");
        assert_eq!(found.matches("<text").count(), 2);
        assert!(found.contains(">CH</text>"));
        assert!(found.contains(">3</text>"));
    }

    #[test]
    fn every_letter_gets_its_own_place() {
        let found = write("CH_3");
        let at = found.find("<text x=\"").unwrap() + "<text x=\"".len();
        let list = &found[at..at + found[at..].find('"').unwrap()];
        assert_eq!(list.split(' ').count(), 2, "x is not given for each letter");
    }

    #[test]
    fn the_two_shapes_place_the_letters_alike() {
        let outline = draw("H_3C-CH_3");
        let text = write("H_3C-CH_3");
        let size = |markup: &str| {
            let at = markup.find("viewBox=\"").unwrap() + "viewBox=\"".len();
            markup[at..at + markup[at..].find('"').unwrap()].to_string()
        };
        assert_eq!(size(&outline), size(&text));
    }

    #[test]
    fn a_character_the_font_lacks_is_written_as_text() {
        let found = draw("\u{3042}-H");
        assert!(found.contains("<text"));
        assert!(found.contains("\u{3042}"));
    }

    #[test]
    fn an_empty_source_still_makes_a_box() {
        let found = draw("");
        assert!(found.starts_with("<svg"));
        assert!(found.ends_with("</svg>"));
    }
}