yog 0.0.2

yog: a balls-oriented session manager for lernie loops (egui frontend)
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
113
114
115
116

//! The V4 board reply's encoders (§8.5, VISION §5 V4): one row, and the §3.5
//! figure shape it carries twice — its own and, for an epic, its rollup.

use serde_json::{Map, Value, json};

use crate::board::BoardRow;
use crate::spend::Figure;

use super::super::codec::join_token;

/// One V4 board row. The column is the answer's headline fact, so it leads;
/// `state` rides beside it because the two say different things (§3.5 binding
/// vs. the ladder). A figure encodes as its money string plus its raw
/// micro-USD, so a reader can render or arithmetic without re-deriving either.
pub(super) fn board_row(row: &BoardRow) -> Value {
    let mut map = Map::new();
    map.insert("id".to_owned(), json!(row.id));
    map.insert("column".to_owned(), json!(row.column.word()));
    map.insert("state".to_owned(), json!(join_token(row.state)));
    map.insert("title".to_owned(), json!(row.title));
    map.insert("priority".to_owned(), json!(row.priority));
    map.insert(
        "project".to_owned(),
        json!(row.project.to_string_lossy().into_owned()),
    );
    if let Some(ws) = &row.workspace {
        map.insert(
            "workspace".to_owned(),
            json!(ws.to_string_lossy().into_owned()),
        );
    }
    if let Some(claimant) = &row.claimant {
        map.insert("claimant".to_owned(), json!(claimant));
    }
    if let Some(parent) = &row.parent {
        map.insert("parent".to_owned(), json!(parent));
    }
    map.insert(
        "gates".to_owned(),
        json!(
            row.gates
                .iter()
                .map(|g| json!({ "id": g.id, "title": g.title, "mints": "close" }))
                .collect::<Vec<Value>>()
        ),
    );
    map.insert(
        "drones".to_owned(),
        json!(
            row.drones
                .iter()
                .map(|d| json!({ "root_id": d.root_id, "name": d.name }))
                .collect::<Vec<Value>>()
        ),
    );
    if let Some(figure) = &row.spend {
        map.insert("spend".to_owned(), figure_value(figure));
    }
    if let Some(figure) = &row.rollup {
        map.insert("rollup".to_owned(), figure_value(figure));
    }
    Value::Object(map)
}

/// One armed loop's facts (VISION §5 V4 item 2), all derived: the cap and its
/// project from the config entry, the count from the rows above, the tick from
/// the clock, the last act from the trail, the lease from the entry, and the
/// ceiling from §3.5's own gate asked over this workspace's spend.
///
/// **The tick is a period, not a countdown.** A level-triggered loop has no
/// phase on disk and must not grow one to render a clock face: what it can
/// truthfully say is how long its period is and how long ago it last changed
/// the world, and `last_act_secs_ago` is absent — not zero — for a loop that
/// never has.
pub(super) fn fleet_facts(facts: &crate::fleet::Facts) -> Value {
    let mut map = Map::new();
    map.insert(
        "workspace".to_owned(),
        json!(facts.workspace.to_string_lossy().into_owned()),
    );
    map.insert(
        "project".to_owned(),
        json!(facts.project.to_string_lossy().into_owned()),
    );
    map.insert("cap".to_owned(), json!(facts.cap));
    map.insert("count".to_owned(), json!(facts.count));
    map.insert("room".to_owned(), json!(facts.has_room()));
    map.insert("tick_secs".to_owned(), json!(facts.tick.as_secs()));
    if let Some(lease) = facts.lease {
        map.insert("lease_secs".to_owned(), json!(lease.as_secs()));
    }
    if let Some(secs) = facts.since_act {
        map.insert("last_act_secs_ago".to_owned(), json!(secs));
    }
    if let Some(ceiling) = &facts.ceiling {
        map.insert("ceiling".to_owned(), json!(ceiling));
    }
    map.insert("label".to_owned(), json!(facts.label()));
    Value::Object(map)
}

/// One §3.5 figure: tokens always, money when the price table has rates, and
/// the granularity clause when the figure is honest at less than it claims.
fn figure_value(figure: &Figure) -> Value {
    let mut map = Map::new();
    map.insert("tokens".to_owned(), json!(figure.tokens.total_tokens()));
    if let Some(cost) = figure.cost {
        map.insert("usd".to_owned(), json!(cost.usd()));
        map.insert("micro_usd".to_owned(), json!(cost.micro_usd));
        map.insert("unpriced_tokens".to_owned(), json!(cost.unpriced_tokens));
    }
    if let Some(note) = figure.attribution.note() {
        map.insert("attribution".to_owned(), json!(note.label));
    }
    Value::Object(map)
}