lernie 0.1.63

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! **The conversation's own records**: the steps its loop took, one step
//! drilled into, what its worktree holds, its undelivered mail, its spine, and
//! the config commit it resolves policy from. What that policy SAYS is next
//! door ([`super::policy`]).

use crate::reply::files::{Files, Preview};
use crate::reply::governing::Governing;
use crate::reply::inbox::Row as InboxRow;
use crate::reply::rail::Rail;
use crate::reply::steps::Steps;

use super::parts::{brief, clause, line, line_over, listing, things, when};

/// **The steps one loop has taken.** One row a step, and the orphan class
/// beside the heading, because it is a statement about the ledger rather than
/// about any row in it.
pub(super) fn steps(steps: &Steps) -> String {
    let rows = steps
        .rows
        .iter()
        .map(|row| {
            line(vec![
                Some(row.seq.clone()),
                Some(row.framing.clone()),
                things(row.attempts, "attempt"),
                Some(format!("{} tokens", row.tokens.total)),
                clause("commit", row.commit.as_deref()),
                clause("started", row.started_at.as_deref()),
                clause("ended", row.ended_at.as_deref()),
                clause("as", row.auth_row.as_deref()),
                when(row.wound != "none", &row.wound),
                clause("—", row.wound_reason.as_deref()),
            ])
        })
        .collect();
    let head = line(vec![
        Some("steps".to_owned()),
        when(steps.orphan != "none", &format!("orphan: {}", steps.orphan)),
        clause("—", steps.orphan_reason.as_deref()),
    ]);
    listing(&head, rows, "this loop has taken no step")
}

/// **What a worktree holds**, and the one file a preview was asked for.
pub(super) fn files(files: &Files) -> String {
    let rows = files
        .listing
        .as_ref()
        .map(|listing| {
            listing
                .rows
                .iter()
                .map(|row| {
                    line(vec![
                        Some(format!("{}{}", row.path, if row.dir { "/" } else { "" })),
                        when(!row.dir, &format!("{} bytes", row.size)),
                    ])
                })
                .collect::<Vec<String>>()
        })
        .unwrap_or_default();
    let head = line(vec![
        Some("files".to_owned()),
        clause("in", files.working_dir.as_deref()),
        when(
            files.listing.as_ref().is_some_and(|l| l.truncated),
            "(truncated)",
        ),
    ]);
    line_over(
        &listing(&head, rows, "no worktree listing came back"),
        files.preview.as_ref().map(|body| preview("preview", body)),
    )
}

/// A bounded log or a file preview, as the three things one can be.
pub(super) fn preview(name: &str, preview: &Preview) -> String {
    match preview {
        Preview::Text(text) => line_over(name, Some(text.clone())),
        Preview::Truncated { text, size } => line_over(
            &format!("{name} (head of {size} bytes)"),
            Some(text.clone()),
        ),
        Preview::Binary { size } => format!("{name}: {size} bytes, binary"),
        Preview::Unknown(word) => {
            format!("{name}: {word} (this seat has no reading of that preview)")
        }
    }
}

/// **The undelivered mail** waiting in one conversation's inbox.
pub(super) fn inbox(rows: &[InboxRow]) -> String {
    let painted = rows
        .iter()
        .map(|row| {
            line_over(
                &line(vec![
                    Some(row.name.clone()),
                    clause("from", row.deposit.said_by().as_deref()),
                    clause("at", row.deposit.deposited_at.as_deref()),
                    clause("epitaph:", row.deposit.epitaph.as_deref()),
                    clause("ref", row.deposit.terminal_ref.as_deref()),
                ]),
                Some(row.deposit.body.clone()),
            )
        })
        .collect();
    listing("inbox", painted, "no mail is waiting")
}

/// **The spine**: the commits a fork may be taken off, and the children
/// already taken off them.
pub(super) fn rail(rail: &Rail) -> String {
    let notches = rail
        .notches
        .iter()
        .map(|notch| {
            line(vec![
                Some(notch.seq.clone()),
                Some(notch.short()),
                when(!notch.operable(), "(not operable)"),
                Some(format!("{} tokens", notch.budget)),
                clause(
                    "seat",
                    notch
                        .seat
                        .as_ref()
                        .map(|seat| format!("{} cut {}", seat.row, seat.cut))
                        .as_deref(),
                ),
            ])
        })
        .chain(rail.cards.iter().map(|card| {
            line(vec![
                Some(format!("↳ {}", card.name)),
                Some(card.state.label()),
                Some(format!("off {}", card.fork)),
                Some(format!("notch {}", card.notch)),
                Some(format!("{} tokens", card.tokens)),
                clause("—", card.tail.as_deref().map(brief).as_deref()),
            ])
        }))
        .collect();
    listing("spine", notches, "no operable commit yet")
}

/// **Which config commit a conversation resolves its policy from.**
pub(super) fn governing(governing: &Governing) -> String {
    listing(
        &line(vec![Some("governing".to_owned()), Some(governing.label())]),
        governing.files.clone(),
        "no file governs it",
    )
}