lernie 0.1.66

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

//! The two walkers, against shapes the vendored corpus does not have. At the
//! cut every stamp is at or below the floor, so a projection over real frames
//! deletes nothing — every arm below would otherwise be an arm nobody has
//! evidence about.

use serde_json::json;

use super::super::Signature;
use super::{mutate, project, spelled, words};

/// A signature, written the way upstream writes one: `<path>:<type>` to the
/// edition the path appeared at.
fn signature(entries: &[(&str, u64)]) -> Signature {
    entries
        .iter()
        .map(|(path, stamp)| ((*path).to_owned(), *stamp))
        .collect()
}

/// A signature entry is a path and the JSON type it is spelled with, and a
/// nullable field is spelled twice — once per type.
#[test]
fn a_signature_entry_is_a_path_and_a_type() {
    assert_eq!(spelled("/rows/[]/held:null"), ("/rows/[]/held", "null"));
    assert_eq!(spelled(":object"), ("", "object"));
    assert_eq!(spelled("nonsense"), ("nonsense", ""));
}

/// **The vocabulary paths are the string-typed ones, and never `kind`.** The
/// discriminant stays strict by name, so mutating it would assert the opposite
/// of the rule (DESIGN §4.9, rung 2 against rung 3).
#[test]
fn the_word_paths_are_the_string_ones_without_the_discriminant() {
    let signature = signature(&[
        ("/kind:string", 1),
        ("/rows/[]/state:string", 1),
        ("/rows/[]/age:number", 1),
        ("/rows:array", 1),
        (":object", 1),
    ]);
    assert_eq!(words(&signature), vec!["/rows/[]/state".to_owned()]);
}

/// **Projection deletes what a stamp says the engine could not write**, at
/// every depth and through every element, and leaves everything at or below
/// the asked-for edition exactly as it was.
#[test]
fn projection_deletes_only_what_is_stamped_later() {
    let signature = signature(&[
        ("/kind:string", 1),
        ("/rows/[]/says:string", 1),
        ("/rows/[]/held:object", 20),
        ("/rows/[]/held/tool:string", 20),
    ]);
    let frame = json!({
        "kind": "follow",
        "rows": [
            {"says": "one", "held": {"tool": "Bash"}},
            {"says": "two"},
        ],
    });
    assert_eq!(
        project(&frame, &signature, 20),
        frame,
        "nothing is later than 20"
    );
    assert_eq!(
        project(&frame, &signature, 19),
        json!({"kind": "follow", "rows": [{"says": "one"}, {"says": "two"}]}),
    );
}

/// **A container's element spelling projects to the empty array**, which is the
/// container's own path saying the same thing one level down.
#[test]
fn projecting_an_element_spelling_empties_the_array() {
    let signature = signature(&[("/rows/[]/signals/[]:string", 20)]);
    let frame = json!({"rows": [{"signals": ["flagged"]}, {"signals": []}]});
    assert_eq!(
        project(&frame, &signature, 19),
        json!({"rows": [{"signals": []}, {"signals": []}]}),
    );
}

/// A path that runs off this particular frame reaches nothing and deletes
/// nothing: a shape spells the union of what its frames hold.
#[test]
fn projecting_a_path_this_frame_does_not_carry_changes_nothing() {
    let signature = signature(&[
        ("/rows/[]/held/tool:string", 20),
        ("/absent/deep:string", 20),
        // The root is no key of anything, so a later stamp on it deletes
        // nothing either.
        (":object", 20),
    ]);
    let frame = json!({"rows": [{"says": "one"}]});
    assert_eq!(project(&frame, &signature, 19), frame);
}

/// **Mutation replaces the word wherever the path reaches a string**, and
/// answers `None` where it reaches none — including where the path reaches a
/// value of another type entirely.
#[test]
fn mutation_sets_every_string_the_path_reaches() {
    let frame = json!({
        "rows": [
            {"state": "running", "signals": ["flagged", "truncated"], "age": 3},
            {"state": "wound"},
        ],
    });
    assert_eq!(
        mutate(&frame, "/rows/[]/state", "unheard-of"),
        Some(json!({
            "rows": [
                {"state": "unheard-of", "signals": ["flagged", "truncated"], "age": 3},
                {"state": "unheard-of"},
            ],
        })),
    );
    assert_eq!(
        mutate(&frame, "/rows/[]/signals/[]", "unheard-of"),
        Some(json!({
            "rows": [
                {"state": "running", "signals": ["unheard-of", "unheard-of"], "age": 3},
                {"state": "wound"},
            ],
        })),
    );
    assert_eq!(mutate(&frame, "/rows/[]/absent", "unheard-of"), None);
    assert_eq!(mutate(&frame, "/rows/[]/age", "unheard-of"), None);
    assert_eq!(mutate(&frame, "", "unheard-of"), None);
}