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

//! The attempt's envelope (VISION V2, bl-dc0c): `{"op":"fork", …}`.
//!
//! Its own module for the same reason the §9 config family has one — the
//! envelope carries a **list** (`skills`), and reading a list strictly needs a
//! reader the scalar fields do not: absence is the empty list, but a present
//! field of the wrong shape is a refusal, like every other mistyped value.
//!
//! **There is no cohort envelope.** A fan is N of these, so the shape carries
//! no count and no group id: there is nothing to name ([`crate::fork`]).

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

use crate::boundary::Action;
use crate::fork::Attempt;

use super::start::encode_path;
use super::{path_of, str_of};

/// Encode one attempt.
pub(super) fn encode(
    workspace: &std::path::Path,
    parent: &str,
    attempt: &Attempt,
    goal: &str,
) -> Value {
    json!({ "op": "fork", "workspace": encode_path(workspace), "parent": parent,
            "from": attempt.from, "role": attempt.role, "skills": attempt.skills,
            "goal": goal })
}

/// Decode one attempt, strictly.
pub(super) fn decode(o: &Map<String, Value>) -> Result<Action, String> {
    Ok(Action::Fork {
        workspace: path_of(o, "workspace")?,
        parent: str_of(o, "parent")?,
        attempt: Attempt {
            from: str_of(o, "from")?,
            role: str_of(o, "role")?,
            skills: words_of(o, "skills")?,
        },
        goal: str_of(o, "goal")?,
    })
}

/// An optional array-of-strings field, read as a list. Absent is the empty
/// list — an attempt that pins nothing says so by saying nothing — but a
/// present field that is not an array of strings is a refusal, because a
/// gesture is an instruction and a mistyped one must not be half-obeyed.
fn words_of(obj: &Map<String, Value>, key: &str) -> Result<Vec<String>, String> {
    let Some(value) = obj.get(key) else {
        return Ok(Vec::new());
    };
    let wrong = || format!("field {key:?} must be an array of strings");
    value
        .as_array()
        .ok_or_else(wrong)?
        .iter()
        .map(|item| item.as_str().map(str::to_owned).ok_or_else(wrong))
        .collect()
}