yog 0.0.25

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
Documentation 
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

//! **The loop does not take back a ball it gave back** (bl-3988, DESIGN §11):
//! the third decision table, cut off [`super`] at §12's cap on the seam the
//! plan draws — the two reap tables say when a claim comes back, and this one
//! says what the loop may take next.

use super::*;
use crate::opslog::OpRow;

/// One `["yog-fleet",<verb>,…]` row in [`WS`], as the loop leaves it.
fn act(verb: &str, ball: &str) -> OpRow {
    let entry = if verb == crate::fleet::row::REAP {
        crate::fleet::row::reaped(
            "1".to_owned(),
            Path::new(WS),
            ball,
            "otter",
            "lease expired 1m ago",
        )
    } else {
        crate::fleet::row::spawned("1".to_owned(), Path::new(WS), ball, "OtterBrook")
    };
    OpRow::from(&entry)
}

/// A world as [`snap`] makes one, carrying `ops` as its trail.
fn with(ops: Vec<OpRow>) -> Snapshot {
    Snapshot {
        ops,
        ..snap(vec![])
    }
}

/// The storm, gone: a ball the loop reaped is not the ball the next tick takes,
/// and the lower-priority work that was starved behind it runs.
#[test]
fn a_reaped_ball_is_not_retaken_and_the_next_ready_ball_runs() {
    let board = vec![
        row("bl-high", Column::Ready, vec![]),
        row("bl-low", Column::Ready, vec![]),
    ];
    let one = plan(
        &with(vec![act(crate::fleet::row::REAP, "bl-high")]),
        &facts(1, 0, None),
        Path::new(fixture::WS),
        &board,
        NOW,
    );
    let Some(Move::Spawn { row }) = one else {
        panic!("a spawn");
    };
    assert_eq!(
        row.id, "bl-low",
        "the board's first ready ball is the one the loop just gave back"
    );
}

/// With nothing else ready, a ball the loop gave back is simply not taken —
/// the loop stops rather than betting the same fire has a different outcome.
#[test]
fn a_reaped_ball_alone_on_the_board_stops_the_loop_rather_than_looping() {
    let board = vec![row("bl-high", Column::Ready, vec![])];
    assert_eq!(
        plan(
            &with(vec![act(crate::fleet::row::REAP, "bl-high")]),
            &facts(1, 0, None),
            Path::new(fixture::WS),
            &board,
            NOW
        ),
        None
    );
}

/// Only the **newest** act decides, and only this workspace's: a ball the loop
/// took after giving it back is takeable again, and another workspace's reap is
/// not this loop's memory.
#[test]
fn the_newest_act_in_this_workspace_is_the_whole_memory() {
    let board = vec![row("bl-high", Column::Ready, vec![])];
    let retaken = vec![
        act(crate::fleet::row::REAP, "bl-high"),
        act(crate::fleet::row::SPAWN, "bl-high"),
    ];
    assert!(
        matches!(
            plan(
                &with(retaken),
                &facts(1, 0, None),
                Path::new(fixture::WS),
                &board,
                NOW
            ),
            Some(Move::Spawn { .. })
        ),
        "the newest act is a spawn, so the loop holds it rather than having given it back"
    );
    let mut elsewhere = act(crate::fleet::row::REAP, "bl-high");
    elsewhere.cwd = "/names/heron".to_owned();
    assert!(
        matches!(
            plan(
                &with(vec![elsewhere]),
                &facts(1, 0, None),
                Path::new(fixture::WS),
                &board,
                NOW
            ),
            Some(Move::Spawn { .. })
        ),
        "another workspace's loop gave that ball back, not this one"
    );
}