lernie 0.1.99

lernie: the operator seat — the window and wire client for a yog server
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! **A notice longer than the rule** (bl-7e3e): it stands whole above the
//! rule at every width, and the rule keeps its one line and its name.

use super::super::READY;
use crate::paint_probe::frame::Window;
use crate::test_support::window::seated;
use crate::ui::{Model, Notice, theme};

/// The longest sentence a notice says, with its remedy at the end.
fn long() -> Notice {
    Notice::InDoubt {
        op: "message".to_owned(),
        why: "the connection closed before the reply, after the engine had read the \
              whole request and could have begun to act on every part of it"
            .to_owned(),
    }
}

/// Collapse every run of whitespace, so a wrapped sentence reads back as the
/// one it was.
fn words(text: &str) -> String {
    text.split_whitespace().collect::<Vec<_>>().join(" ")
}

/// **What two settled frames of the whole window put on the glass** at this
/// size: the bottom panels are laid where they stand on the frame after the
/// one that measured them.
fn glass(model: &mut Model, w: f32, h: f32) -> Vec<crate::paint_probe::Seen> {
    let window = Window::sized(w, h);
    window.frame(Vec::new(), |ctx| crate::ui::render(ctx, model));
    crate::test_support::window::seen(&window, |ctx| crate::ui::render(ctx, model))
}

/// **At the desk and at the phone the whole sentence reaches the glass**,
/// uncut and inside the window, its remedy included, above the rule and
/// under the box — and the rule under it still says where you are: the slot
/// its calm word, the name at its end.
#[test]
fn a_long_notice_stands_whole_above_the_rule_at_every_width() {
    for (w, h) in [(1400.0, 900.0), (400.0, 800.0)] {
        let mut model = seated();
        model.notice = Some(long());
        let seen = glass(&mut model, w, h);
        let ink = theme::accent(theme::State::Error);
        let said: Vec<_> = seen.iter().filter(|run| run.ink == ink).collect();
        let read = words(&said.iter().map(|run| run.text.as_str()).collect::<String>());
        assert_eq!(read, words(&long().line()), "at {w}: the whole sentence");
        for run in &said {
            assert_eq!(run.shown, run.laid, "at {w}: {:?} is cut", run.text);
            assert!(run.laid.max.x <= w, "at {w}: {:?} runs off", run.text);
        }
        // The lowest run reading the name — cut at the phone, where the bar
        // takes its glyph column: the card at the head says it too.
        let rule = seen
            .iter()
            .filter(|run| run.text.starts_with("port t"))
            .max_by(|a, b| a.laid.min.y.total_cmp(&b.laid.min.y))
            .unwrap_or_else(|| panic!("at {w}: the rule's name is on the glass"));
        let lowest = said.iter().map(|run| run.laid.max.y).fold(0.0, f32::max);
        assert!(
            lowest <= rule.laid.min.y,
            "at {w}: the notice is above the rule"
        );
        // And under the box (DESIGN §4.45 item 3): the rule is under the box
        // now, and the notice is the rule's.
        let prompt = seen
            .iter()
            .filter(|run| run.text == theme::glyph::PROMPT && run.ink == theme::BRAND)
            .map(|run| run.laid.max.y)
            .fold(0.0, f32::max);
        let highest = said.iter().map(|run| run.laid.min.y).fold(h, f32::min);
        assert!(prompt <= highest, "at {w}: the notice is under the box");
        // At the phone the diagnostics have dropped (item 11): the selectors
        // still say what you are talking to.
        assert!(
            seen.iter().any(|run| run.text.starts_with("pro")),
            "at {w}: the provider"
        );
        if w > 1000.0 {
            assert!(
                seen.iter().any(|run| run.text.contains("quiescent")),
                "at {w}: the slot says the calm state"
            );
            assert!(
                seen.iter()
                    .any(|run| run.text
                        == crate::test_support::window::dropped(super::super::NO_MODEL)),
                "at {w}: the notice costs no fact"
            );
        }
    }
}

/// **A notice that fits beside every fact stays in the slot**, on the rule's
/// one line, and the slot says nothing calm beside it.
#[test]
fn a_short_notice_stays_in_the_slot() {
    let mut model = Model {
        notice: Some(Notice::Said("the act landed".to_owned())),
        ..Model::default()
    };
    let seen = glass(&mut model, 1400.0, 900.0);
    let note = seen
        .iter()
        .find(|run| run.text == "the act landed")
        .expect("the notice is on the glass");
    let name = seen
        .iter()
        .find(|run| run.text == super::super::ENGINES)
        .expect("the rule's name is on the glass");
    assert!((note.laid.center().y - name.laid.center().y).abs() < 2.0);
    assert!(!seen.iter().any(|run| run.text == READY));
}