sim-nest 0.1.5

The SIM constellation umbrella facade: one crate that re-exports the runtime kernel, codecs, number domains, and libraries behind features.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use sim_kernel::{Expr, Symbol};
use sim_lib_midi_core::{MetaEvent, MidiEvent, MidiPayload, TickTime, synthetic_origin};
use sim_lib_music_core::{Articulation, Channel, Melody, MelodyItem, Music, Note, Score, Time};
use sim_lib_pitch_core::Pitch;
use sim_lib_sound_shapes::encode_tuning_descriptor;
use sim_lib_sound_tuning::TuningDescriptor;

use super::support::{codec_symbols, cx, decode_once, encode_once};

/// A roundtrip corpus case: an expression plus an assertion over its decode.
type Roadmap11Case = (Expr, fn(&Expr));

fn roadmap11_corpus() -> Vec<Roadmap11Case> {
    vec![
        (
            Expr::Extension {
                tag: Symbol::qualified("pitch", "Pitch"),
                payload: Box::new(Expr::String("C4".to_owned())),
            },
            |expr| {
                let Expr::Extension { tag, payload } = expr else {
                    panic!("expected extension");
                };
                assert_eq!(tag, &Symbol::qualified("pitch", "Pitch"));
                let Expr::String(text) = payload.as_ref() else {
                    panic!("expected string payload");
                };
                sim_lib_pitch_shapes::decode_pitch(text).expect("pitch parse");
            },
        ),
        (
            Expr::Extension {
                tag: Symbol::qualified("midi", "MidiEvent"),
                payload: Box::new(Expr::String(sim_lib_midi_shapes::encode_midi_event(
                    &MidiEvent {
                        time: TickTime::new(480, 480).expect("tick"),
                        origin: synthetic_origin(),
                        payload: MidiPayload::Meta(MetaEvent::EndOfTrack),
                    },
                ))),
            },
            |expr| {
                let Expr::Extension { tag, payload } = expr else {
                    panic!("expected extension");
                };
                assert_eq!(tag, &Symbol::qualified("midi", "MidiEvent"));
                let Expr::String(text) = payload.as_ref() else {
                    panic!("expected string payload");
                };
                sim_lib_midi_shapes::decode_midi_event(text).expect("midi parse");
            },
        ),
        (
            Expr::Extension {
                tag: Symbol::qualified("music", "Score"),
                payload: Box::new(Expr::String(sim_lib_music_shapes::encode_music_file(
                    &Score::new(
                        120,
                        (4, 4),
                        Some("C major".to_owned()),
                        Music::Melody(
                            Melody::new(vec![MelodyItem::Note(
                                Note::new(
                                    Time::new(1, 4),
                                    Pitch::from_midi(60),
                                    100,
                                    Channel::new(0).expect("channel"),
                                    Articulation::Normal,
                                )
                                .expect("note"),
                            )])
                            .expect("melody"),
                        ),
                    )
                    .expect("score"),
                ))),
            },
            |expr| {
                let Expr::Extension { tag, payload } = expr else {
                    panic!("expected extension");
                };
                assert_eq!(tag, &Symbol::qualified("music", "Score"));
                let Expr::String(text) = payload.as_ref() else {
                    panic!("expected string payload");
                };
                sim_lib_music_shapes::decode_music_file(text).expect("music parse");
            },
        ),
        (
            Expr::Extension {
                tag: Symbol::qualified("sound", "TuningDescriptor"),
                payload: Box::new(Expr::String(encode_tuning_descriptor(
                    &TuningDescriptor::EqualTemperament {
                        divisions: 12,
                        reference_midi: 69,
                        reference_hz: 440.0,
                    },
                ))),
            },
            |expr| {
                let Expr::Extension { tag, payload } = expr else {
                    panic!("expected extension");
                };
                assert_eq!(tag, &Symbol::qualified("sound", "TuningDescriptor"));
                let Expr::String(text) = payload.as_ref() else {
                    panic!("expected string payload");
                };
                sim_lib_sound_shapes::decode_tuning_descriptor(text).expect("sound parse");
            },
        ),
    ]
}

#[test]
fn roadmap11_layer_values_roundtrip_through_installed_codecs() {
    let mut cx = cx();
    for codec in codec_symbols() {
        for (expr, validate) in roadmap11_corpus() {
            let encoded = encode_once(&mut cx, &codec, &expr);
            let decoded = decode_once(&mut cx, &codec, encoded);
            assert!(
                decoded.canonical_eq(&expr),
                "codec {} failed roadmap11 roundtrip {:?} -> {:?}",
                codec,
                expr,
                decoded
            );
            validate(&decoded);
        }
    }
}