yog 0.0.55

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

//! **The gesture surface** (bl-32cb): one populated value per boundary
//! spelling, assembled from the family lists the round trips are already cut
//! along.
//!
//! It has two readers and that is the point. The codec's own round trip walks
//! it — encode → decode is the identity over every entry — and
//! [`crate::boundary::corpus`] renders it into the conformance corpus every
//! wire client replays. One list, so a fixture a client is judged against and a
//! fixture yog proves itself against can never be two different things.
//!
//! Where a variant carries an enum, a bounded option or a collection, the list
//! holds **one entry per arm** and the empty case beside the populated one: a
//! table that only ever spells the easy case proves only that the easy case
//! crosses.

mod ball;
mod conversation;

use crate::boundary::Gesture;

/// Every gesture, in family order. Deterministic — the corpus is a committed
/// artifact, so the order this returns is part of what is committed.
pub(crate) fn gestures() -> Vec<Gesture> {
    [
        conversation::surface(),
        ball::surface(),
        super::start::surface(),
        super::fan::surface(),
        super::fork::surface(),
        super::control::surface(),
        super::fleet::surface(),
        super::retarget::surface(),
        super::query::surface(),
        login(),
        pins(),
        enroll(),
        crate::boundary::codec::config::tests::surface(),
    ]
    .concat()
}

/// The §4.1 pin (bl-b986) — **one entry per direction**, because the direction
/// is the op token and a fixture that only ever spelled `pin` would leave the
/// instruction that is not the default unproven on the wire.
fn pins() -> Vec<Gesture> {
    [true, false]
        .into_iter()
        .map(|pinned| {
            Gesture::Act(crate::boundary::Action::Pin {
                workspace: "ws".to_owned(),
                pinned,
            })
        })
        .collect()
}

/// The §8.3 sign-in (REMOTE §8.3, bl-c285) — one entry, because the act's
/// whole envelope is the pair it names: the flow is the row's own capability
/// and never a field a seat spells (DESIGN §8.3 rule 1), so there is no arm
/// here for a fixture to walk.
fn login() -> Vec<Gesture> {
    vec![Gesture::Act(crate::boundary::Action::Login {
        workspace: "ws".to_owned(),
        provider: "acme".to_owned(),
    })]
}

/// REMOTE §1.4's enrollment (bl-f4e3) — **one entry per grade**, because the
/// grade is a two-armed vocabulary and a fixture that only ever spelled the
/// default would prove only that the default crosses. And one more with the
/// address the DEVICE will dial stated (bl-fec6, PROTOCOL 14), because an
/// optional field that no fixture carries is a field the corpus cannot see.
fn enroll() -> Vec<Gesture> {
    let request = |grade, address: Option<&str>| {
        Gesture::Act(crate::boundary::Action::Enroll(
            crate::registry::enroll::Request {
                workspace: "ws".to_owned(),
                name: "phone-1".to_owned(),
                grade,
                address: address.map(str::to_owned),
            },
        ))
    };
    vec![
        request(crate::registry::Grade::Operator, None),
        request(crate::registry::Grade::Foot, None),
        request(
            crate::registry::Grade::Operator,
            Some("engine.invalid:7737"),
        ),
    ]
}