blockworx/edit/

describe.rs

//! What a commit is called: the verb the gesture opened under, the entity
//! its ops touched, and the scope it happened in.
//!
//! One builder for every tool, because a history list whose rows are
//! written by twenty call sites is a list whose rows disagree. A gesture
//! knows its verb before it knows its object — the object is whatever the
//! ops turn out to name — so the two meet here, at the seal.
//!
//! Names are read from the document the commit was written *against*
//! ([`named`]), so a label says what a thing was called when it happened
//! rather than chasing a later rename.
//!
//! **The label does not name the scope.** §8.1 gives the scope a line of
//! its own on every history row, recorded at seal beside the ids, so a
//! label that appended `in <scope>` would say it twice — and say it worse,
//! since the row's line elides from the left to keep the leaf while the
//! label's suffix would be truncated leaf-first.

use blockworx_doc::{
    block_model::{AreaUpdate, BlockUpdate, LabelUpdate, PinUpdate, RouteUpdate, TextUpdate},
    document::{Document, IndexedDocument, TitleBlockUpdate},
    id::{AreaId, BlockId, ImageId, PinId, RouteId, RouteLabelId, TextId},
    opcode::{Crud, OpCodes},
};

/// What a gesture is called, before its ops are known.
///
/// The two arms are the two kinds of label there are: a *verb*, which is
/// only half a sentence and is finished here once the ops say what it
/// acted on, and a label that already says everything — an import names
/// the file it brought in, and appending the twenty entities that file
/// carried would say less, not more.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Label {
    Verb(&'static str),
    Verbatim(String),
}

impl Label {
    pub fn verb(verb: &'static str) -> Self {
        Label::Verb(verb)
    }

    pub fn verbatim(label: impl Into<String>) -> Self {
        Label::Verbatim(label.into())
    }

    /// The finished label for a commit carrying `ops`, written against
    /// `document`.
    pub fn describing(&self, document: &IndexedDocument<'_>, ops: &[OpCodes]) -> String {
        match self {
            Label::Verbatim(label) => label.clone(),
            Label::Verb(verb) => {
                let Said {
                    verb: instead,
                    object,
                } = subject(document, ops);
                capitalized(&format!("{} {object}", instead.unwrap_or(verb)))
            }
        }
    }
}

/// What the ops turned out to say: the object half of the sentence, and —
/// where the ops know their verb better than the gesture that opened —
/// the verb to say it with. Naming a thing that had no name is not a
/// rename, whatever the gesture called itself.
struct Said {
    verb: Option<&'static str>,
    object: String,
}

impl Said {
    /// The gesture's own verb stands.
    fn of(object: String) -> Self {
        Said { verb: None, object }
    }
}

/// A name with nothing in it is no name — the one trim, so "untitled"
/// means the same thing everywhere.
fn nonblank(name: Option<String>) -> Option<String> {
    name.map(|name| name.trim().to_owned())
        .filter(|name| !name.is_empty())
}

/// The untitled fallback, spelled once: `"Filter"` or `untitled block`.
fn called(noun: &str, name: Option<String>) -> String {
    match nonblank(name) {
        Some(name) => format!("{noun} \u{201c}{name}\u{201d}"),
        None => format!("untitled {noun}"),
    }
}

/// A bare name, for the places a label points at a thing rather than
/// introducing it (a route's endpoints, a PDF outline entry): `Filter`, or
/// `untitled block`.
pub(crate) fn bare(noun: &str, name: Option<String>) -> String {
    nonblank(name).unwrap_or_else(|| format!("untitled {noun}"))
}

/// How wide a quoted excerpt of authored text may read in a label.
const EXCERPT: usize = 40;

/// `text` as a one-line label can carry it: whitespace flattened, clipped
/// to [`EXCERPT`] characters with an ellipsis. `None` when nothing is
/// left to quote.
fn excerpt(text: &str) -> Option<String> {
    let flat = text.split_whitespace().collect::<Vec<_>>().join(" ");
    if flat.is_empty() {
        return None;
    }
    Some(if flat.chars().count() > EXCERPT {
        flat.chars()
            .take(EXCERPT - 1)
            .collect::<String>()
            .trim_end()
            .to_owned()
            + "\u{2026}"
    } else {
        flat
    })
}

fn capitalized(text: &str) -> String {
    let mut chars = text.chars();
    match chars.next() {
        None => String::new(),
        Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
    }
}

/// The entity a target names, as a reader would say it. `Target` rather
/// than the op itself so a run of ops on one entity — the shape nearly
/// every gesture takes — reads as that entity rather than as its op count.
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
enum Target {
    Document,
    Block(BlockId),
    Pin(PinId),
    Route(RouteId),
    Text(TextId),
    Area(AreaId),
    Image(ImageId),
    RouteLabel(RouteLabelId),
}

impl Target {
    /// The plural a run of these reads as.
    fn plural(self) -> &'static str {
        match self {
            Target::Document => "documents",
            Target::Block(_) => "blocks",
            Target::Pin(_) => "pins",
            Target::Route(_) => "routes",
            Target::Text(_) => "text boxes",
            Target::Area(_) => "areas",
            Target::Image(_) => "images",
            Target::RouteLabel(_) => "route labels",
        }
    }

    fn same_kind(self, other: Self) -> bool {
        self.plural() == other.plural()
    }
}

/// What an op acts on. Only an artwork payload answers `None`: it is
/// bytes rather than an entity, and always travels beside the op that
/// places it.
fn target(op: &OpCodes) -> Option<Target> {
    Some(match op {
        OpCodes::Document(_) => Target::Document,
        OpCodes::Block(id, _) => Target::Block(*id),
        OpCodes::Pin(id, _) => Target::Pin(*id),
        OpCodes::Route(id, _) => Target::Route(*id),
        OpCodes::Text(id, _) => Target::Text(*id),
        OpCodes::Area(id, _) => Target::Area(*id),
        OpCodes::Image(id, _) => Target::Image(*id),
        OpCodes::RouteLabel(id, _) => Target::RouteLabel(*id),
        OpCodes::Asset(..) => return None,
    })
}

/// A rename-shaped op: the noun for the label it writes, the value the
/// document still holds (the commit is sealed against its pre-image), and
/// the value the op carries. One list, so every renamable label — a
/// title, a type label, a pin's name or tag, a route's name, an area's
/// title, the document's own — reads the same way.
struct Renaming<'a> {
    noun: &'static str,
    was: Option<String>,
    to: &'a str,
}

fn renaming<'a>(doc: &Document, op: &'a OpCodes) -> Option<Renaming<'a>> {
    let label = |noun, was: Option<&String>, to| Renaming {
        noun,
        was: was.cloned(),
        to,
    };
    Some(match op {
        OpCodes::Document(TitleBlockUpdate::Name(to)) => {
            label("diagram", Some(&doc.title_block().name), to)
        }
        OpCodes::Block(id, Crud::Update(BlockUpdate::Title(LabelUpdate::Name(to)))) => label(
            "block",
            doc.block(id).map(|block| block.title.name.clone()).as_ref(),
            to,
        ),
        OpCodes::Block(id, Crud::Update(BlockUpdate::TypeLabel(LabelUpdate::Name(to)))) => label(
            "block type",
            doc.block(id)
                .map(|block| block.type_label.name.clone())
                .as_ref(),
            to,
        ),
        OpCodes::Area(id, Crud::Update(AreaUpdate::Title(LabelUpdate::Name(to)))) => label(
            "area",
            doc.area(id).map(|area| area.title.name.clone()).as_ref(),
            to,
        ),
        OpCodes::Pin(id, Crud::Update(PinUpdate::Name(to))) => {
            label("pin", doc.pin(id).map(|pin| pin.name.clone()).as_ref(), to)
        }
        OpCodes::Pin(id, Crud::Update(PinUpdate::TypeName(to))) => label(
            "pin type",
            doc.pin(id).map(|pin| pin.type_name.clone()).as_ref(),
            to,
        ),
        OpCodes::Pin(id, Crud::Update(PinUpdate::Tag(to))) => label(
            "pin tag",
            doc.pin(id).map(|pin| pin.tag.clone()).as_ref(),
            to,
        ),
        OpCodes::Route(id, Crud::Update(RouteUpdate::Name(to))) => label(
            "route",
            doc.route(id).map(|route| route.name.clone()).as_ref(),
            to,
        ),
        _ => return None,
    })
}

/// The sentence a rename-shaped op says, or `None` when it writes an
/// empty name — clearing a label is not "renaming it to nothing", so it
/// falls back to naming the entity alone.
fn renamed(doc: &Document, op: &OpCodes) -> Option<Said> {
    let Renaming { noun, was, to } = renaming(doc, op)?;
    let to = nonblank(Some(to.to_owned()))?;
    Some(match nonblank(was) {
        // Nothing to rename *from*: the gesture's "Rename" is the wrong
        // word for it, whichever tool opened.
        None => Said {
            verb: Some("Name"),
            object: called(noun, Some(to)),
        },
        Some(was) => Said::of(format!(
            "{} to \u{201c}{to}\u{201d}",
            called(noun, Some(was))
        )),
    })
}

/// What `ops` acted on: the one entity where they agree on one, a count
/// otherwise.
fn subject(document: &IndexedDocument<'_>, ops: &[OpCodes]) -> Said {
    let mut named: Vec<(Target, &OpCodes)> = Vec::new();
    for op in ops {
        let Some(target) = target(op) else { continue };
        if !named.iter().any(|(seen, _)| *seen == target) {
            named.push((target, op));
        }
    }
    match named.as_slice() {
        // Reachable only by a commit of pure artwork payload, which no
        // gesture produces on its own — the placement travels with it.
        [] => Said::of("the drawing".to_owned()),
        [(target, op)] => one(document, *target, op),
        [(first, _), rest @ ..] => {
            let count = rest.len() + 1;
            let kind = if rest.iter().all(|(target, _)| target.same_kind(*first)) {
                first.plural()
            } else {
                "shapes"
            };
            Said::of(format!("{count} {kind}"))
        }
    }
}

fn one(document: &IndexedDocument<'_>, target: Target, op: &OpCodes) -> Said {
    if let Some(said) = renamed(document.doc, op) {
        return said;
    }
    // A text box's content *is* its name, so an edit quotes what it now
    // says rather than what it used to.
    if let OpCodes::Text(_, Crud::Update(TextUpdate::Text(to))) = op {
        return match excerpt(to) {
            Some(shown) => Said::of(format!("text to \u{201c}{shown}\u{201d}")),
            None => Said::of("text".to_owned()),
        };
    }
    // A wire drawn this very commit is not in the document yet, so its
    // endpoints come out of the op that creates it.
    if let OpCodes::Route(_, Crud::Create(init)) = op {
        return Said::of(format!("route {}", between(document, init.from, init.to)));
    }
    let name = named(document.doc, op);
    match target {
        Target::Document => Said::of("the diagram".to_owned()),
        Target::Block(_) => Said::of(called("block", name)),
        Target::Pin(_) => Said::of(called("pin", name)),
        Target::Text(_) => Said::of(called("text", name)),
        Target::Area(_) => Said::of(called("area", name)),
        // Neither carries a name of its own, so neither gets the
        // "untitled" hedge: an image is an image.
        Target::Image(_) => Said::of("image".to_owned()),
        Target::RouteLabel(_) => Said::of("route label".to_owned()),
        Target::Route(id) => match document.doc.route(&id) {
            None => Said::of(called("route", name)),
            Some(ends) => Said::of(format!(
                "{} {}",
                called("route", name),
                between(document, ends.from, ends.to)
            )),
        },
    }
}

/// The target's display name in `doc`, the document the op was written
/// against. A create names what it is about to call the entity — the
/// document cannot, since the entity is not in it yet — and everything
/// else reads the name the entity carried before the commit. Kinds with
/// nothing a human would call a name have none.
fn named(doc: &Document, op: &OpCodes) -> Option<String> {
    match op {
        OpCodes::Document(_) => non_empty(&doc.title_block().name),
        OpCodes::Block(id, crud) => crud_name(
            doc.block(id),
            crud,
            |init| &init.title.name,
            |block| &block.title.name,
        ),
        OpCodes::Pin(id, crud) => crud_name(doc.pin(id), crud, |init| &init.name, |pin| &pin.name),
        OpCodes::Route(id, crud) => {
            crud_name(doc.route(id), crud, |init| &init.name, |route| &route.name)
        }
        OpCodes::Text(id, crud) => {
            crud_name(doc.text(id), crud, |init| &init.text, |text| &text.text)
        }
        OpCodes::Area(id, crud) => crud_name(
            doc.area(id),
            crud,
            |init| &init.title.name,
            |area| &area.title.name,
        ),
        OpCodes::RouteLabel(..) | OpCodes::Image(..) | OpCodes::Asset(..) => None,
    }
}

fn crud_name<E, I, U>(
    entity: Option<&E>,
    crud: &Crud<I, U>,
    of_init: impl Fn(&I) -> &String,
    of_entity: impl Fn(&E) -> &String,
) -> Option<String> {
    non_empty(match crud {
        Crud::Create(init) => of_init(init),
        _ => of_entity(entity?),
    })
}

fn non_empty(name: &str) -> Option<String> {
    (!name.is_empty()).then(|| name.to_owned())
}

/// A route's endpoints as a reader points at them — the block each sits
/// on and the pin's own name — which is how a wire is recognized, since
/// the wire itself is usually unnamed.
fn between(document: &IndexedDocument<'_>, from: PinId, to: PinId) -> String {
    let end = |id: PinId| {
        let pin = document.doc.pin(&id);
        let owner = pin
            .map(|pin| pin.owner)
            .and_then(|owner| document.doc.block(&owner));
        format!(
            "{}:{}",
            bare("block", owner.map(|block| block.title.name.clone()),),
            bare("pin", pin.map(|pin| pin.name.clone())),
        )
    };
    format!("from {} to {}", end(from), end(to))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::widget::test_fixtures::{self as fx, Scene};
    use blockworx_doc::fixtures::block_id;
    use blockworx_geom::{Rect, pos2};

    /// A block gesture names the block and the scope it happened in — the
    /// punch list's own example, built from real ops against a real
    /// document.
    /// The label names the entity and stops there: §8.1 gives the scope
    /// its own line on the row, so a label that appended it would say it
    /// twice.
    #[test]
    fn a_label_names_the_entity_and_leaves_the_scope_to_the_row() {
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),
            fx::titled(1, "Amplifier"),
            fx::block_in(
                2,
                crate::path::Scope::Block(block_id(1)),
                Rect::from_min_max(pos2(4.0, 4.0), pos2(24.0, 24.0)),
            ),
            fx::titled(2, "Filter"),
        ]);
        let ops = vec![blockworx_store::fixture::block_move(2, 5)];

        let said = Label::verb("Resize").describing(&scene.indexed(), &ops);
        assert_eq!(said, "Resize block \u{201c}Filter\u{201d}");
    }

    /// An entity with no name of its own still reads as itself.
    #[test]
    fn an_untitled_entity_still_reads_as_itself() {
        let mut scene = Scene::new(vec![fx::block(1, 0.0), fx::titled(1, "")]);
        let ops = vec![blockworx_store::fixture::block_move(1, 5)];
        assert_eq!(
            Label::verb("Move").describing(&scene.indexed(), &ops),
            "Move untitled block",
        );
    }

    #[test]
    fn a_verbatim_label_is_left_exactly_as_it_was_minted() {
        let mut scene = Scene::new(Vec::new());
        assert_eq!(
            Label::verbatim("Imported motor.svg").describing(
                &scene.indexed(),
                &[blockworx_store::fixture::block_create(1, "Adder")],
            ),
            "Imported motor.svg",
        );
    }

    /// A run of ops on one entity is that entity, not its op count; a run
    /// across several is counted, and counted by kind where they agree.
    #[test]
    fn one_entity_reads_as_itself_and_many_read_as_a_count() {
        let mut scene = Scene::new(vec![fx::block(1, 0.0), fx::titled(1, "Filter")]);

        let twice = vec![
            blockworx_store::fixture::block_move(1, 5),
            blockworx_store::fixture::block_rename(1, "Filter II"),
        ];
        assert_eq!(
            Label::verb("edit").describing(&scene.indexed(), &twice),
            "Edit block \u{201c}Filter\u{201d}",
            "two ops on one block are one block",
        );

        let several = vec![
            blockworx_store::fixture::block_create(2, "A"),
            blockworx_store::fixture::block_create(3, "B"),
        ];
        assert_eq!(
            Label::verb("delete").describing(&scene.indexed(), &several),
            "Delete 2 blocks",
        );
    }

    /// The one gesture whose ops are mostly payload: an image places a
    /// content-addressed asset beside the entity that carries it, and the
    /// label must name the entity rather than the bytes.
    #[test]
    fn an_image_reads_as_an_image_rather_than_as_its_payload() {
        use blockworx_doc::block_model::Asset;
        use blockworx_doc::opcode::Crud;

        let mut scene = Scene::new(Vec::new());
        let asset = Asset::Svg(b"<svg/>".to_vec().into());
        let ops = vec![
            OpCodes::Asset(asset.hash(), asset.clone()),
            OpCodes::Image(
                blockworx_doc::fixtures::image_id(1),
                Crud::Update(blockworx_doc::block_model::ImageUpdate::Asset(asset.hash())),
            ),
        ];
        assert_eq!(
            Label::verb("Add").describing(&scene.indexed(), &ops),
            "Add image",
        );
    }

    /// Two wired blocks: `Filter`'s `out` to the default-titled `c`'s
    /// `in`, with the wire itself unnamed until a test names it.
    fn scene_with_a_wire() -> Scene {
        use blockworx_doc::values::PinSide;
        Scene::new(vec![
            fx::block(1, 0.0),
            fx::titled(1, "Filter"),
            fx::block(2, 200.0),
            fx::pin_at(
                1,
                crate::path::Scope::Block(block_id(1)),
                "out",
                fx::slot(PinSide::East, 1),
                Rect::ZERO,
            ),
            fx::pin_at(
                2,
                crate::path::Scope::Block(block_id(2)),
                "in",
                fx::slot(PinSide::West, 1),
                Rect::ZERO,
            ),
            fx::route(1, crate::path::Scope::Root, 1, 2, &[]),
        ])
    }

    /// A wire is recognized by what it joins, so its endpoints are named
    /// by their block *and pin* — one spelling, whether the wire is being
    /// drawn or edited afterwards.
    #[test]
    fn a_route_reads_by_the_ends_it_joins() {
        use blockworx_doc::geometry::{GridPoint, Waypoint};
        let mut scene = scene_with_a_wire();
        scene.apply(vec![fx::route_named(1, "clk")]);
        let bend = vec![OpCodes::Route(
            blockworx_doc::fixtures::route_id(1),
            Crud::Update(RouteUpdate::Waypoints(vec![Waypoint {
                pos: GridPoint { x: 4, y: 4 },
                locked: false,
            }])),
        )];

        let said = Label::verb("Modify").describing(&scene.indexed(), &bend);
        assert_eq!(
            said,
            "Modify route \u{201c}clk\u{201d} from Filter:out to c:in"
        );
    }

    /// Drawing a wire says which two ends it joined — the wire is not in
    /// the document yet, so the endpoints come out of the op itself.
    #[test]
    fn creating_a_route_names_its_endpoints() {
        use blockworx_doc::values::PinSide;
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),
            fx::titled(1, "Filter"),
            fx::block(2, 200.0),
            fx::pin_at(
                1,
                crate::path::Scope::Block(block_id(1)),
                "out",
                fx::slot(PinSide::East, 1),
                Rect::ZERO,
            ),
            fx::pin_at(
                2,
                crate::path::Scope::Block(block_id(2)),
                "in",
                fx::slot(PinSide::West, 1),
                Rect::ZERO,
            ),
        ]);
        assert!(
            scene
                .indexed()
                .doc
                .route(&blockworx_doc::fixtures::route_id(1))
                .is_none(),
            "precondition: the wire is created by the ops under test, not before them",
        );
        let drawn = vec![fx::route(1, crate::path::Scope::Root, 1, 2, &[])];
        assert_eq!(
            Label::verb(crate::tools::names::ToolName::Route.verb())
                .describing(&scene.indexed(), &drawn),
            "Create route from Filter:out to c:in",
        );
    }

    /// A rename says what it replaced: at the seal the document is still
    /// the pre-image, so the old value is read from it and the new one
    /// from the op.
    #[test]
    fn a_rename_carries_the_value_it_replaces() {
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),
            fx::titled(1, "Amplifier"),
            fx::block_in(
                2,
                crate::path::Scope::Block(block_id(1)),
                Rect::from_min_max(pos2(4.0, 4.0), pos2(24.0, 24.0)),
            ),
            fx::titled(2, "Filter"),
        ]);
        assert_eq!(
            Label::verb("Rename").describing(&scene.indexed(), &[fx::titled(2, "Notch")]),
            "Rename block \u{201c}Filter\u{201d} to \u{201c}Notch\u{201d}",
        );
    }

    /// Nothing to rename *from* is not a rename, whichever tool opened
    /// the gesture: the op's own verb wins over the gesture's.
    #[test]
    fn naming_something_that_had_no_name_is_not_a_rename() {
        let mut scene = Scene::new(vec![fx::block(1, 0.0), fx::titled(1, "")]);
        assert_eq!(
            Label::verb("Rename").describing(&scene.indexed(), &[fx::titled(1, "Mixer")],),
            "Name block \u{201c}Mixer\u{201d}",
        );
        // Clearing a name is neither: there is no new value to quote, so
        // the gesture's own verb and the entity alone are what is left.
        assert_eq!(
            Label::verb("Rename").describing(&scene.indexed(), &[fx::titled(1, "")],),
            "Rename untitled block",
        );
    }

    /// One rule, every renamable label — a drifting second spelling for
    /// pin tags or type labels is exactly what the single builder exists
    /// to prevent.
    #[test]
    fn every_rename_shaped_op_reads_the_same_way() {
        use blockworx_doc::values::PinSide;
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),
            fx::titled(1, "Filter"),
            fx::typed(1, "SVF"),
            fx::pin_at(
                1,
                crate::path::Scope::Block(block_id(1)),
                "out",
                fx::slot(PinSide::East, 1),
                Rect::ZERO,
            ),
            fx::pin_typed(1, "analog"),
            fx::pin_tagged(1, "J1"),
        ]);
        let mut said = |op| Label::verb("Rename").describing(&scene.indexed(), &[op]);
        assert_eq!(
            said(fx::typed(1, "Ladder")),
            "Rename block type \u{201c}SVF\u{201d} to \u{201c}Ladder\u{201d}",
        );
        assert_eq!(
            said(OpCodes::Pin(
                blockworx_doc::fixtures::pin_id(1),
                Crud::Update(PinUpdate::Name("outp".into())),
            )),
            "Rename pin \u{201c}out\u{201d} to \u{201c}outp\u{201d}",
        );
        assert_eq!(
            said(fx::pin_typed(1, "digital")),
            "Rename pin type \u{201c}analog\u{201d} to \u{201c}digital\u{201d}",
        );
        assert_eq!(
            said(fx::pin_tagged(1, "J2")),
            "Rename pin tag \u{201c}J1\u{201d} to \u{201c}J2\u{201d}",
        );
        let mut wired = scene_with_a_wire();
        wired.apply(vec![fx::route_named(1, "clk")]);
        assert_eq!(
            Label::verb("Rename").describing(&wired.indexed(), &[fx::route_named(1, "clock")],),
            "Rename route \u{201c}clk\u{201d} to \u{201c}clock\u{201d}",
        );
    }

    /// A text box's content is what it is called, so an edit quotes what
    /// it now says — flattened onto one line and clipped, since a log row
    /// is not a place to reproduce a paragraph.
    #[test]
    fn a_text_edit_quotes_what_it_now_says() {
        let mut scene = Scene::new(vec![fx::text(
            1,
            crate::path::Scope::Root,
            "old note",
            pos2(0.0, 0.0),
        )]);
        let mut edit = |content: &str| {
            Label::verb("Edit").describing(&scene.indexed(), &[fx::text_content(1, content)])
        };
        assert_eq!(
            edit("first line\nsecond line"),
            "Edit text to \u{201c}first line second line\u{201d}",
        );
        let long = edit(&"wide ".repeat(20));
        assert!(
            long.ends_with('\u{201d}') && long.contains('\u{2026}'),
            "a long run must be clipped with an ellipsis: {long}",
        );
        let quoted = long
            .trim_start_matches("Edit text to \u{201c}")
            .trim_end_matches('\u{201d}');
        assert_eq!(
            quoted.chars().count(),
            EXCERPT,
            "the excerpt is clipped to its width: {quoted:?}",
        );
        // Emptying a text box has nothing to quote.
        assert_eq!(edit("   "), "Edit text");
    }
}