write_till_receipt.rs

//! Creates the receipt a shop's till prints on a roll: the shop at the head,
//! the basket line by line, the tax gathered by rate, what was handed over and
//! what was handed back, and the ticket's own barcode at the foot.
//!
//! The roll is 80 mm across, which is the paper a counter printer takes, and
//! the page is as long as this basket makes it. Every figure on it is worked
//! out rather than written down: a line comes to its quantity times its unit
//! price, the tax at each rate is taken out of the gross that carries it, the
//! total is the sum of the lines, and the change is what is left of the note
//! handed over.
//!
//! The barcode is what the shop scans when the ticket comes back — a return, an
//! exchange, a warranty claim. `Code128::automatic` reads the number and picks
//! the code set for it: a ticket number of nothing but digits goes into code
//! set C, two digits to a symbol, and takes 112 modules where code set B would
//! spell it out over 189.
//!
//! Whether that barcode scans is not for the page to say, and not for an eye: a
//! scanner says. `scripts/check_barcode.sh` points a decoder at the rendered
//! page and reads the number back.
//!
//! Every word the ticket prints is held in `Words`, once per language, and
//! `HQF_PDF_LANG` picks which one it is printed in. What is not language stays
//! out of it: the shop, the date, the till, the amounts, the rates and the
//! ticket number read the same whichever set of words is drawn.
//!
//! Usage: `cargo run --example write_till_receipt -- tmp/receipt.pdf
//! [font.ttf]`
//!        `HQF_PDF_LANG=fr cargo run --example write_till_receipt --
//! tmp/ticket.pdf`

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

use hqf_pdf::content::Content;
use hqf_pdf::cos::Name;
use hqf_pdf::{Code128, Dash, Document, Font, FontHandle, Page, Rgb};

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

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

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

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

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 roll, in points: 80 mm across, cut long enough for this basket.
const PAGE_WIDTH: f64 = 226.772;
const PAGE_HEIGHT: f64 = 486.0;

/// The margins the printer keeps clear, and the middle a centred line sits on.
const LEFT: f64 = 14.0;
const RIGHT: f64 = PAGE_WIDTH - LEFT;
const CENTRE: f64 = PAGE_WIDTH / 2.0;

/// Where the first baseline sits, in points down from the top of the roll.
const HEAD_TOP: f64 = 24.0;

/// The steps the ticket comes down the roll by: between two lines of a block,
/// between two blocks, from one article to the next, and from an article to the
/// quantity line under it.
const LINE: f64 = 10.0;
const BLOCK: f64 = 13.0;
const ITEM: f64 = 20.0;
const SUB: f64 = 8.0;

/// The sizes the ticket is set at: the shop's name, the small print, the body
/// of the basket, the line the ticket ends on, and the total.
const SHOP_SIZE: f64 = 13.0;
const SMALL: f64 = 6.5;
const BODY: f64 = 8.0;
const THANKS_SIZE: f64 = 7.5;
const TOTAL_SIZE: f64 = 11.0;

/// The near-black a till prints in, and the grey the labels and the small print
/// are set in.
const INK: Rgb = Rgb {
    r: 0.1,
    g: 0.1,
    b: 0.12,
};
const MUTED: Rgb = Rgb {
    r: 0.42,
    g: 0.42,
    b: 0.45,
};

/// The shop: its name, where it stands, what to ring, and the number it is
/// registered for tax under. It is the same shop whichever language the ticket
/// is printed in.
const SHOP: &str = "Comptoir Vaugelade";
const ADDRESS: &str = "18 rue des Trois-Fontaines";
const TOWN: &str = "13290 Les Milles";
const PHONE: &str = "+33 4 42 00 71 30";
const REGISTRATION: &str = "FR 41 802 337 190";

/// When the basket was rung up, at which till, and by whom.
const DATE: &str = "2026-08-31";
const TIME: &str = "18:42";
const TILL: &str = "04";
const CASHIER: &str = "Naïma";

/// The ticket's own number: the till, the day, and the basket's place in the
/// day. Nothing but digits, which is what sends it into code set C.
const TICKET: &str = "04202608310731";

/// The currency every amount on the ticket is in.
const CURRENCY: &str = "EUR";

/// What was handed over, in cents.
const TENDERED: i64 = 6000;

/// The width of the narrowest bar, in points. Everything else is a whole number
/// of these.
const MODULE: f64 = 1.0;

/// How tall the bars are drawn, in points.
const BAR_HEIGHT: f64 = 34.0;

/// The right edge of two of the three columns of figures in the tax table. The
/// third ends at the right margin, and the rate is set from the left one.
const NET_RIGHT: f64 = 120.0;
const TAX_RIGHT: f64 = 166.0;

/// A rate of tax: the reduced rate a grocer charges on food, and the standard
/// rate on everything else.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Rate {
    /// The reduced rate.
    Reduced,
    /// The standard rate.
    Standard,
}

impl Rate {
    /// The rate itself, in tenths of a percent.
    const fn tenths(self) -> i64 {
        match self {
            Self::Reduced => 55,
            Self::Standard => 200,
        }
    }

    /// The letter the ticket marks a line with, and the tax table names.
    const fn letter(self) -> &'static str {
        match self {
            Self::Reduced => "A",
            Self::Standard => "B",
        }
    }

    /// The rate as the ticket writes it: a point before the tenth, and a
    /// no-break space before the sign.
    fn shown(self) -> String {
        let tenths = self.tenths();
        format!("{}.{}\u{00A0}%", tenths / 10, tenths % 10)
    }
}

/// Both rates, in the order the tax table sets them out.
const RATES: [Rate; 2] = [Rate::Reduced, Rate::Standard];

/// One line of the basket: how many were scanned, what one of them costs in
/// cents, and the rate of tax it carries. What the article is called is a word,
/// and is held in `Words` at the place the line has here.
#[derive(Debug)]
struct Article {
    /// How many of it were scanned.
    quantity: i64,
    /// What one of them costs, in cents.
    unit: i64,
    /// The rate of tax it carries.
    rate: Rate,
}

/// The basket, in the order it was scanned.
const BASKET: [Article; 6] = [
    Article {
        quantity: 1,
        unit: 120,
        rate: Rate::Reduced,
    },
    Article {
        quantity: 2,
        unit: 890,
        rate: Rate::Reduced,
    },
    Article {
        quantity: 3,
        unit: 105,
        rate: Rate::Reduced,
    },
    Article {
        quantity: 1,
        unit: 1240,
        rate: Rate::Reduced,
    },
    Article {
        quantity: 1,
        unit: 675,
        rate: Rate::Standard,
    },
    Article {
        quantity: 1,
        unit: 995,
        rate: Rate::Standard,
    },
];

/// Every word the ticket prints, in one language.
///
/// What is not language stays out of it: the shop, its address, the date, the
/// till, the cashier, the amounts, the rates and the ticket number are drawn
/// from constants of their own and read the same in every language.
#[derive(Debug)]
struct Words {
    /// What the file says it is, and the line under the shop's name.
    title: &'static str,
    tagline: &'static str,
    /// What the shop's tax registration stands under.
    registration: &'static str,
    /// The five marks at the head of the ticket.
    date: &'static str,
    time: &'static str,
    till: &'static str,
    served: &'static str,
    receipt: &'static str,
    /// The two column heads over the basket.
    item: &'static str,
    amount: &'static str,
    /// The six articles, in the order the basket holds them.
    articles: [&'static str; 6],
    /// The line that adds the basket up before tax, and the four column heads
    /// of the tax table.
    net_total: &'static str,
    rate: &'static str,
    net: &'static str,
    tax: &'static str,
    gross: &'static str,
    /// What the ticket comes to, what was handed over, what was handed back,
    /// and how many articles were sold.
    total: &'static str,
    cash: &'static str,
    change: &'static str,
    count: &'static str,
    /// The two lines under the barcode.
    keep: &'static str,
    thanks: &'static str,
}

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

/// The ticket in English.
const ENGLISH: Words = Words {
    title: "Till receipt",
    tagline: "Grocer and general store",
    registration: "VAT no.",
    date: "DATE",
    time: "TIME",
    till: "TILL",
    served: "SERVED BY",
    receipt: "RECEIPT",
    item: "ITEM",
    amount: "AMOUNT",
    articles: [
        "Sourdough loaf",
        "Coffee beans 1 kg",
        "Whole milk 1 L",
        "Olive oil 75 cl",
        "Washing powder 2 kg",
        "Batteries AA, 8",
    ],
    net_total: "TOTAL BEFORE TAX",
    rate: "RATE",
    net: "NET",
    tax: "TAX",
    gross: "GROSS",
    total: "TOTAL",
    cash: "CASH",
    change: "CHANGE",
    count: "ARTICLES SOLD",
    keep: "Keep this ticket for any return or exchange.",
    thanks: "Thank you for your visit — see you soon",
};

/// The ticket in French.
const FRENCH: Words = Words {
    title: "Ticket de caisse",
    tagline: "Épicerie et bazar",
    registration: "TVA n°",
    date: "DATE",
    time: "HEURE",
    till: "CAISSE",
    served: "SERVI PAR",
    receipt: "TICKET",
    item: "ARTICLE",
    amount: "MONTANT",
    articles: [
        "Pain au levain",
        "Café en grains 1 kg",
        "Lait entier 1 L",
        "Huile d'olive 75 cl",
        "Lessive en poudre 2 kg",
        "Piles AA, 8",
    ],
    net_total: "TOTAL HORS TAXE",
    rate: "TAUX",
    net: "HT",
    tax: "TVA",
    gross: "TTC",
    total: "TOTAL",
    cash: "ESPÈCES",
    change: "RENDU",
    count: "ARTICLES VENDUS",
    keep: "Conservez ce ticket pour tout retour ou échange.",
    thanks: "Merci de votre visite — à bientôt",
};

/// 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)];

/// An amount of cents, its thousands parted by a no-break space and its
/// decimals by a point, which is how every language this example is written in
/// writes one.
///
/// The currency is named once at the head of the column of amounts and once on
/// the line of the total; the figures themselves are bare, as a till prints
/// them.
fn money(cents: i64) -> String {
    let (whole, fraction) = (cents / 100, cents % 100);
    let digits = whole.to_string();
    let mut out = String::with_capacity(digits.len() + 8);
    for (index, digit) in digits.chars().enumerate() {
        if index > 0 && (digits.len() - index) % 3 == 0 {
            out.push('\u{00A0}');
        }
        out.push(digit);
    }
    format!("{out}.{fraction:02}")
}

/// What one line of the basket comes to, in cents.
const fn line_total(article: &Article) -> i64 {
    article.quantity * article.unit
}

/// What the whole basket comes to, in cents.
fn total() -> i64 {
    BASKET.iter().map(line_total).sum()
}

/// How many articles were sold, all lines together.
fn sold() -> i64 {
    BASKET.iter().map(|article| article.quantity).sum()
}

/// What the lines carrying `rate` come to, in cents, tax included.
fn gross_at(rate: Rate) -> i64 {
    BASKET
        .iter()
        .filter(|article| article.rate == rate)
        .map(line_total)
        .sum()
}

/// What `gross` holds of tax at `rate`, in cents, rounded to the nearest cent.
///
/// The prices a shop shows already carry their tax, so the tax is taken out of
/// the gross rather than added to a net: at a rate of `t` tenths of a percent,
/// it is `gross × t / (1000 + t)`.
const fn tax_of(gross: i64, rate: Rate) -> i64 {
    let tenths = rate.tenths();
    let denominator = 1000 + tenths;
    (gross * tenths * 2 + denominator) / (denominator * 2)
}

/// The bars the ticket carries.
///
/// The number is nothing but digits, so `automatic` takes code set C for it and
/// draws it in a little over half the bars code set B would spell it out in.
///
/// # Errors
///
/// If the ticket number holds a character Code 128 cannot carry, or none at
/// all.
fn ticket_code() -> Result<Code128, hqf_pdf::Error> {
    Code128::automatic(TICKET)
}

/// Draws a line of text, left-aligned, in a colour of its own.
fn text(content: &mut Content, font: &FontHandle, size: f64, x: f64, y: f64, color: Rgb, s: &str) {
    let _ = content.set_fill(color);
    content.begin_text();
    let _ = content.set_font(font, size);
    let _ = content.text_origin(x, y);
    content.show_glyphs(&font.glyphs(s));
    content.end_text();
}

/// Draws a line of text whose right edge sits at `right`.
fn text_right(
    content: &mut Content,
    font: &FontHandle,
    size: f64,
    right: f64,
    y: f64,
    color: Rgb,
    s: &str,
) {
    text(
        content,
        font,
        size,
        right - font.measure(s, size),
        y,
        color,
        s,
    );
}

/// Draws a line of text set across the middle of the roll.
fn text_centre(content: &mut Content, font: &FontHandle, size: f64, y: f64, color: Rgb, s: &str) {
    text(
        content,
        font,
        size,
        CENTRE - font.measure(s, size) / 2.0,
        y,
        color,
        s,
    );
}

/// Draws a row with something at the left margin and something at the right.
fn row(
    content: &mut Content,
    font: &FontHandle,
    size: f64,
    y: f64,
    color: Rgb,
    left: &str,
    right: &str,
) {
    text(content, font, size, LEFT, y, color, left);
    text_right(content, font, size, RIGHT, y, color, right);
}

/// Draws the row of dashes a till prints between the parts of a ticket.
fn dashes(content: &mut Content, y: f64) -> Result<(), hqf_pdf::Error> {
    content.set_stroke(MUTED)?;
    content.set_line_width(0.5)?;
    content.set_dash(&Dash::on_off(2.0, 2.0)?)?;
    content.move_to(LEFT, y)?;
    content.line_to(RIGHT, y)?;
    content.stroke();
    content.set_solid();
    Ok(())
}

/// Draws the shop at the head of the roll, and hands back the baseline it ends
/// on.
fn head(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    text_centre(content, font, SHOP_SIZE, y, INK, SHOP);
    y -= 12.0;
    text_centre(content, font, SMALL, y, MUTED, words.tagline);
    y -= LINE;
    text_centre(content, font, SMALL, y, INK, ADDRESS);
    y -= SUB;
    text_centre(content, font, SMALL, y, INK, TOWN);
    y -= SUB;
    text_centre(content, font, SMALL, y, INK, PHONE);
    y -= SUB;
    let registered = format!("{} {REGISTRATION}", words.registration);
    text_centre(content, font, SMALL, y, MUTED, &registered);
    y
}

/// Draws when the basket was rung up, at which till, by whom and under which
/// number, and hands back the baseline it ends on.
fn marks(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    let day = format!("{} {DATE}", words.date);
    let hour = format!("{} {TIME}", words.time);
    row(content, font, SMALL, y, INK, &day, &hour);
    y -= LINE;
    let till = format!("{} {TILL}", words.till);
    let served = format!("{} {CASHIER}", words.served);
    row(content, font, SMALL, y, INK, &till, &served);
    y -= LINE;
    row(content, font, SMALL, y, INK, words.receipt, TICKET);
    y
}

/// Draws the basket, one article to two lines: what it is against what it came
/// to, and under that how many at what price and which rate it carries. Hands
/// back the baseline it ends on.
fn basket(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    for (article, name) in BASKET.iter().zip(words.articles) {
        let amount = money(line_total(article));
        row(content, font, BODY, y, INK, name, &amount);

        let counted = format!("{} × {}", article.quantity, money(article.unit));
        text(content, font, SMALL, LEFT + SUB, y - SUB, MUTED, &counted);
        let letter = article.rate.letter();
        text_right(content, font, SMALL, RIGHT, y - SUB, MUTED, letter);
        y -= ITEM;
    }
    y + ITEM - SUB
}

/// Draws what the basket comes to before tax and the tax gathered by rate, and
/// hands back the baseline it ends on.
fn taxes(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    let before_tax: i64 = RATES
        .iter()
        .map(|&rate| {
            let gross = gross_at(rate);
            gross - tax_of(gross, rate)
        })
        .sum();
    let amount = money(before_tax);
    row(content, font, BODY, y, INK, words.net_total, &amount);

    y -= BLOCK;
    text(content, font, SMALL, LEFT, y, MUTED, words.rate);
    text_right(content, font, SMALL, NET_RIGHT, y, MUTED, words.net);
    text_right(content, font, SMALL, TAX_RIGHT, y, MUTED, words.tax);
    text_right(content, font, SMALL, RIGHT, y, MUTED, words.gross);

    for rate in RATES {
        y -= LINE;
        let gross = gross_at(rate);
        let tax = tax_of(gross, rate);
        let named = format!("{} {}", rate.letter(), rate.shown());
        text(content, font, SMALL, LEFT, y, INK, &named);
        text_right(content, font, SMALL, NET_RIGHT, y, INK, &money(gross - tax));
        text_right(content, font, SMALL, TAX_RIGHT, y, INK, &money(tax));
        text_right(content, font, SMALL, RIGHT, y, INK, &money(gross));
    }
    y
}

/// Draws what the ticket came to, what was handed over and what was handed
/// back, and hands back the baseline it ends on.
fn settlement(content: &mut Content, font: &FontHandle, words: &Words, top: f64) -> f64 {
    let mut y = top;
    let due = total();
    let paid = format!("{}\u{00A0}{CURRENCY}", money(due));
    row(content, font, TOTAL_SIZE, y, INK, words.total, &paid);

    y -= BLOCK;
    row(content, font, BODY, y, INK, words.cash, &money(TENDERED));
    y -= LINE;
    let change = money(TENDERED - due);
    row(content, font, BODY, y, INK, words.change, &change);
    y -= LINE;
    row(
        content,
        font,
        SMALL,
        y,
        MUTED,
        words.count,
        &sold().to_string(),
    );
    y
}

/// Draws the ticket's own barcode and the two lines under it, and hands back
/// the baseline it ends on.
fn foot(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
    top: f64,
) -> Result<f64, Box<dyn std::error::Error>> {
    let code = ticket_code()?;
    let width = f64::from(u32::try_from(code.module_count())?) * MODULE;

    // The quiet zone is the caller's: nothing else is drawn beside the bars,
    // and the roll leaves far more than the ten modules a scanner needs.
    let mut y = top - BAR_HEIGHT;
    content.set_fill(Rgb::gray(0.0))?;
    content.draw_barcode(&code, (PAGE_WIDTH - width) / 2.0, y, width, BAR_HEIGHT)?;

    y -= LINE;
    text_centre(content, font, SMALL, y, INK, TICKET);
    y -= LINE;
    text_centre(content, font, SMALL, y, MUTED, words.keep);
    y -= 12.0;
    text_centre(content, font, THANKS_SIZE, y, INK, words.thanks);
    Ok(y)
}

/// Draws the whole ticket, and hands back the baseline it ends on.
fn ticket(
    content: &mut Content,
    font: &FontHandle,
    words: &Words,
) -> Result<f64, Box<dyn std::error::Error>> {
    let mut y = head(content, font, words, PAGE_HEIGHT - HEAD_TOP);

    y -= BLOCK;
    dashes(content, y)?;
    y = marks(content, font, words, y - BLOCK);

    y -= BLOCK;
    dashes(content, y)?;
    y -= BLOCK;
    let heading = format!("{}\u{00A0}{CURRENCY}", words.amount);
    row(content, font, SMALL, y, MUTED, words.item, &heading);
    y = basket(content, font, words, y - 12.0);

    y -= BLOCK;
    dashes(content, y)?;
    y = taxes(content, font, words, y - BLOCK);

    y -= BLOCK;
    dashes(content, y)?;
    y = settlement(content, font, words, y - 16.0);

    foot(content, font, words, y - 18.0)
}

fn main() -> std::process::ExitCode {
    failure::reported(run())
}

fn run() -> 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 path = args
        .next()
        .unwrap_or_else(|| language.file_name(&out::default_path("till_receipt")));
    let font_path = args.next().map_or_else(default_font, PathBuf::from);

    let mut doc = Document::new();
    doc.set_license(licence::licensed());
    doc.set_info(Name::new("Title"), &format!("{} {TICKET}", words.title));

    let font = doc.add_font(Font::parse(fs::read(&font_path)?)?);

    let mut content = Content::new();
    ticket(&mut content, &font, words)?;

    let mut page = Page::new(PAGE_WIDTH, PAGE_HEIGHT);
    page.content = content.into_bytes();
    doc.add_page(page)?;

    let bytes = doc.to_bytes()?;
    if let Some(parent) = Path::new(&path).parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(&path, &bytes)?;

    println!(
        "wrote {path}: {} bytes, ticket {TICKET}, {} articles, {}\u{00A0}{CURRENCY}",
        bytes.len(),
        sold(),
        money(total())
    );
    Ok(())
}

#[cfg(test)]
mod tests {
    use hqf_pdf::{Code128, Content, Document, Font};

    use super::{
        BASKET, BODY, LEFT, RATES, RIGHT, Rate, SMALL, TICKET, WORDS, default_font, gross_at,
        language, line_total, money, tax_of, ticket, ticket_code, total,
    };

    /// The lines two languages are allowed to write the same way, each with
    /// what makes the two the same word.
    const SPARED: [&str; 2] = [
        // A day is headed by the same word in French as in English.
        r#"date: "DATE""#,
        // So is the line a ticket ends on.
        r#"total: "TOTAL""#,
    ];

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

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

    /// An amount over a thousand holds its thousands apart, and every amount
    /// puts a point before its cents.
    #[test]
    fn an_amount_is_written_with_a_space_between_its_thousands() {
        assert_eq!(money(123_456_789), "1\u{00A0}234\u{00A0}567.89");
        assert_eq!(money(5125), "51.25");
        assert_eq!(money(105), "1.05");
    }

    /// The tax table has to add up to the ticket: every line of the basket is
    /// gathered under one of the two rates, and every net, taxed again the
    /// other way round, comes back to the gross it was taken out of.
    #[test]
    fn the_tax_table_adds_up_to_what_the_ticket_comes_to() {
        let mut gross_sum = 0;

        for rate in RATES {
            let gross = gross_at(rate);
            assert!(gross > 0, "no line carries {}", rate.letter());

            let net = gross - tax_of(gross, rate);
            let grossed_again = (net * (1000 + rate.tenths()) + 500) / 1000;
            assert_eq!(
                grossed_again,
                gross,
                "{net} taxed at {} comes back to {grossed_again}, not to {gross}",
                rate.shown()
            );
            gross_sum += gross;
        }

        assert_eq!(
            gross_sum,
            total(),
            "the rates gather {gross_sum} of a basket that came to {}",
            total()
        );

        // A tax that does not fall on a whole cent goes to the nearer one
        // rather than being cut short: a fifth of 10.00 is 1.666…, and 12.40 at
        // the reduced rate holds 0.646…
        assert_eq!(tax_of(1000, Rate::Standard), 167);
        assert_eq!(tax_of(1240, Rate::Reduced), 65);
    }

    /// The ticket number is nothing but digits, so the bars the ticket carries
    /// are the ones code set C draws, over fewer modules than code set B would
    /// spell the number out in. Both counts are held to the module: code set C
    /// pairs the fourteen digits into seven symbols where code set B spells out
    /// fourteen, each set adding a start symbol and a check symbol, every
    /// symbol covering eleven modules and the stop pattern thirteen.
    #[test]
    fn the_ticket_number_is_drawn_in_the_narrower_code_set() {
        let chosen = ticket_code().expect("the ticket number is digits");
        let spelled = Code128::new(TICKET).expect("the ticket number is printable");

        assert_eq!(
            chosen.module_count(),
            112,
            "code set C draws {TICKET} over {} modules",
            chosen.module_count()
        );
        assert_eq!(
            spelled.module_count(),
            189,
            "code set B draws {TICKET} over {} modules",
            spelled.module_count()
        );
    }

    /// Nothing on the ticket is broken to a width: a line wider than the roll
    /// runs off the paper.
    #[test]
    fn every_language_prints_lines_that_fit_the_roll() {
        let mut doc = Document::new();
        let font = doc.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        );
        let room = RIGHT - LEFT;

        for (named, words) in WORDS {
            for line in [words.keep, words.thanks, words.tagline, words.net_total] {
                let measured = font.measure(line, SMALL);
                assert!(
                    measured <= room,
                    "the {} ticket sets {line:?} over {measured:.1} points, and it \
                     has {room:.1}",
                    named.code()
                );
            }
        }
    }

    /// An article's name and what it came to share one line, and neither may
    /// run into the other.
    #[test]
    fn every_article_leaves_room_for_what_it_came_to() {
        let mut doc = Document::new();
        let font = doc.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        );
        let room = RIGHT - LEFT;

        for (named, words) in WORDS {
            for (article, name) in BASKET.iter().zip(words.articles) {
                let amount = money(line_total(article));
                let measured = font.measure(name, BODY) + font.measure(&amount, BODY);
                assert!(
                    measured + SMALL <= room,
                    "the {} ticket sets {name:?} and {amount:?} over {measured:.1} \
                     points, and the line has {room:.1}",
                    named.code()
                );
            }
        }
    }

    /// The roll is cut to a length, and the last line has to land on it.
    #[test]
    fn the_ticket_ends_on_the_paper() {
        let mut doc = Document::new();
        let font = doc.add_font(
            Font::parse(std::fs::read(default_font()).expect("the committed font is there"))
                .expect("the committed font parses"),
        );

        for (named, words) in WORDS {
            let mut content = Content::new();
            let last = ticket(&mut content, &font, words).expect("the ticket draws");
            assert!(
                last >= SMALL,
                "the {} ticket ends on a line at {last:.1} points, and the roll \
                 stops at 0",
                named.code()
            );
        }
    }
}