lernie 0.1.24

lernie: the operator seat — the window and wire client for a yog server
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

//! **The aimed wall's half of the ball pane** (bl-d2af): what this wall holds,
//! what each of them has cost, and the branch its `bl` verbs track on.
//!
//! Two ops, both naming a workspace, so both are the tuning pane's shape
//! rather than the board's: they stand while this pane is open and are retired
//! when the aim moves (`crate::ui::model::board`). It is a section of the
//! board rather than a pane of its own because *the board* and *what this wall
//! holds* are one question asked at two widths, and two panes would put them
//! on two screens.
//!
//! **Every emptiness gets its own sentence**, which is the rule the records
//! pane states and this section has four of: no wall aimed at, a wall not yet
//! answered about, a wall that answered and holds nothing, and a wall whose
//! branch is the only thing that came back. Painting one sentence over all
//! four would say *this wall holds nothing* about a wall nobody has asked.

use crate::reply::balls::BoundBall;
use crate::ui::{Model, theme};

/// What it says with no wall aimed at.
pub const UNAIMED: &str = "aim at a workspace to see the balls it holds";
/// What it says about a wall nobody has been answered about yet.
pub const NOT_ANSWERED: &str = "waiting to hear what this workspace holds";
/// What it says about a wall that answered and holds none.
pub const NOTHING: &str = "this workspace holds no balls";

/// Paint the section.
pub fn render(ui: &mut egui::Ui, model: &Model) {
    ui.separator();
    let Some(aim) = model.aim.clone() else {
        ui.label(UNAIMED);
        return;
    };
    ui.label(aim.address);
    if let Some(branch) = &model.marks {
        ui.colored_label(
            theme::tone_ink(&crate::reply::convs::Tone::Weak),
            tracking(branch),
        );
    }
    let Some(rows) = model.holding.as_deref() else {
        ui.label(NOT_ANSWERED);
        return;
    };
    if rows.is_empty() {
        ui.label(NOTHING);
        return;
    }
    for row in rows {
        ui.label(bound(row));
        ui.colored_label(
            theme::tone_ink(&crate::reply::convs::Tone::Weak),
            super::cost(&row.spend),
        );
    }
}

/// **The branch this wall tracks its tasks on.** Every agent tracks in a task
/// space of its own so two agents' churn never collides, and `balls/tasks` is
/// the project's shared board — which is why the branch is worth a line: it is
/// how an operator tells the one from the other.
pub fn tracking(branch: &str) -> String {
    format!("tracking tasks on {branch}")
}

/// **One ball this wall holds**: what it is, where its verbs run, and the name
/// they stamp. The badge rides where the engine wrote one and is absent —
/// never blank — where the state needs none.
pub fn bound(row: &BoundBall) -> String {
    let mut said = vec![row.id.clone(), format!("[{}]", row.state)];
    if let Some(badge) = &row.badge {
        said.push(badge.clone());
    }
    said.push(format!("in {} as {}", row.project, row.owner));
    said.join("  ")
}

#[cfg(test)]
mod tests;