Changing style in the middle of a paragraph

//! Sets paragraphs whose style changes inside them: sizes that shift mid-line,
//! a total that is underlined, and a word that turns underlined halfway
//! through.
//!
//! Each block is laid out in the same box, so a line is as tall as the tallest
//! style standing on it, and an underline is drawn where each font says one
//! goes.
//!
//! The paragraphs are held in `Words`, once per language, and `HQF_PDF_LANG`
//! picks which set is set. Each is cut around the run whose style changes, so
//! that a language says what it has to say around the same three pieces.
//!
//! Usage: `cargo run --example write_rich_text -- tmp/rich.pdf [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_rich_text -- tmp/riche.pdf`

use std::env;
use std::fs;
use std::path::{Path, PathBuf};

use hqf_pdf::content::Content;
use hqf_pdf::layout::{RichText, Style};
use hqf_pdf::{Align, Document, Font, Page, Rgb};

#[path = "shared/out.rs"]
mod out;

#[path = "shared/licence.rs"]
mod licence;

#[path = "shared/language.rs"]
mod language;

use language::Language;

/// The font the example draws with when none is given on the command line.
fn default_font() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("fonts")
        .join("DejaVuSans.ttf")
}

/// The left edge of every box, in points.
const LEFT: f64 = 56.0;
/// The width every paragraph is broken to.
const WIDTH: f64 = 420.0;
/// The top of the first box.
const TOP: f64 = 760.0;
/// The gap between one block and the next.
const GAP: f64 = 26.0;

/// The sum the first paragraph is about. A total is not language.
const AMOUNT: &str = "1 240.00 EUR";

/// The words the page is set in, one set per language.
///
/// Every paragraph is cut around the run that carries the style being shown, so
/// the piece that is underlined, enlarged or coloured is a piece of the
/// sentence rather than a sentence of its own.
#[derive(Debug)]
struct Words {
    /// The line at the head of the page.
    title: &'static str,
    /// The first paragraph, cut around the amount it names.
    due: [&'static str; 2],
    /// The second, cut around the run set in the largest type.
    tallest: [&'static str; 3],
    /// The third, cut around the run that carries its own colour.
    coloured: [&'static str; 3],
    /// The fourth, cut in the middle of a word: the second piece turns
    /// underlined without the word being broken at the join.
    joined: [&'static str; 3],
    /// The fifth, cut around the run named by the alignment it is set to.
    small: [&'static str; 3],
}

impl Words {
    /// The words the page is set in, in `language`.
    fn of(language: Language) -> &'static Self {
        language::pick(&WORDS, language)
    }
}

/// The page in English.
const ENGLISH: Words = Words {
    title: "Rich text: styles, sizes, underlining, colour",
    due: [
        "The amount due is ",
        ", payable within thirty days. The balance carries interest at the \
         statutory rate from the day it falls due, and no reminder has to be \
         sent for it to do so.",
    ],
    tallest: [
        "A line is as tall as ",
        "the largest",
        " of the styles standing on it, and no taller.",
    ],
    coloured: [
        "A run can carry its own ",
        "colour",
        ", set apart from the black around it.",
    ],
    joined: [
        "A word may change style in the middle: under",
        "lined",
        " is still one word, and is never broken at the join.",
    ],
    small: [
        "The small print sits in small type, ",
        "flush right",
        ", below the body of the text.",
    ],
};

/// The page in French.
const FRENCH: Words = Words {
    title: "Texte enrichi : styles, tailles, soulignement, couleur",
    due: [
        "Le montant dû est de ",
        ", payable sous trente jours. Le solde porte intérêt au taux légal à \
         compter du jour de son échéance, sans qu'aucun rappel n'ait à être \
         envoyé.",
    ],
    tallest: [
        "Une ligne est aussi haute que ",
        "le plus grand",
        " des styles qui s'y tiennent, et pas davantage.",
    ],
    coloured: [
        "Un passage peut porter sa propre ",
        "couleur",
        ", distincte du noir qui l'entoure.",
    ],
    joined: [
        "Un mot peut changer de style en son milieu : souli",
        "gné",
        " reste un seul mot, et n'est jamais coupé à la jointure.",
    ],
    small: [
        "Les mentions légales sont en petits caractères, ",
        "alignées à droite",
        ", sous le corps du texte.",
    ],
};

/// Every language the example is written in. A language is added by writing its
/// own set of words and naming it here.
static WORDS: [(Language, &Words); 2] =
    [(Language::English, &ENGLISH), (Language::French, &FRENCH)];

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let language = Language::from_environment()?;
    let words = Words::of(language);

    let mut args = env::args().skip(1);
    // A named file is written as named; the default one carries the language,
    // so the two languages do not overwrite each other in `tmp/`.
    let out = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("rich")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

    let font = Font::parse(fs::read(&font_path)?)?;
    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    let text = doc.add_font(font);

    let regular = Style::new(&text, 11.0);
    let small = Style::new(&text, 8.0);
    let large = Style::new(&text, 17.0);
    let marked = Style::new(&text, 11.0).underline();
    let accent = Style::new(&text, 11.0).color(Rgb::new(0.0, 0.35, 0.7));

    let blocks = vec![
        RichText::new()
            .align(Align::Justify)
            .push(words.due[0], &regular)
            .push(AMOUNT, &marked)
            .push(words.due[1], &regular),
        RichText::new()
            .push(words.tallest[0], &regular)
            .push(words.tallest[1], &large)
            .push(words.tallest[2], &regular),
        RichText::new()
            .push(words.coloured[0], &regular)
            .push(words.coloured[1], &accent)
            .push(words.coloured[2], &regular),
        RichText::new()
            .push(words.joined[0], &regular)
            .push(words.joined[1], &marked)
            .push(words.joined[2], &regular),
        RichText::new()
            .align(Align::Right)
            .push(words.small[0], &small)
            .push(words.small[1], &small)
            .push(words.small[2], &small),
    ];

    let mut content = Content::new();
    content.begin_text();
    content.set_font(text.name(), 14.0)?;
    content.text_origin(LEFT, TOP + 24.0)?;
    content.show_glyphs(&text.glyphs(words.title));
    content.end_text();

    let mut top = TOP;
    for block in &blocks {
        let lines = block.break_lines(WIDTH);
        block.draw(&mut content, &lines, LEFT, top, WIDTH)?;
        top -= RichText::height(&lines) + GAP;
    }

    let mut page = Page::a4();
    page.content = content.into_bytes();
    doc.add_page(page)?;

    let bytes = doc.to_bytes()?;
    if let Some(parent) = Path::new(&out).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&out, &bytes)?;
    println!(
        "wrote {out}: {} bytes, {} blocks",
        bytes.len(),
        blocks.len()
    );
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::{WORDS, language};

    /// The lines two languages are allowed to write the same way. Every
    /// paragraph here is a sentence, and no two languages write one alike.
    const SPARED: [&str; 0] = [];

    #[test]
    fn every_language_sets_the_page_in_its_own_words() {
        let untranslated = language::untranslated_lines(&WORDS, &SPARED);

        assert!(
            untranslated.is_empty(),
            "the page says these in more than one language: {untranslated:?}"
        );
    }

    /// The fourth paragraph exists to show that a word whose halves are set in
    /// two styles is still one word. A language that gives the underlined run a
    /// word of its own shows nothing, and the page reads as if the run had been
    /// emphasised in the ordinary way.
    #[test]
    fn every_language_turns_a_word_underlined_halfway_through() {
        for (language, words) in WORDS {
            let [before, run, after] = words.joined;
            let code = language.code();
            assert!(
                !before.ends_with(' '),
                "{code} starts the underlined run on a word of its own"
            );
            assert!(
                !run.starts_with(' ') && !run.ends_with(' '),
                "{code} pads the underlined run with spaces"
            );
            assert!(
                after.starts_with(' '),
                "{code} carries the word on past the underlining"
            );
        }
    }
}