bliplab 0.0.3

Tool to combine several BLIP channels in a song
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

#![doc = "../README.md"]

use std::{borrow::Cow, collections::HashMap, path::PathBuf};

use bliplib::compiler::Expression;
use derive_new::new;
use serde::{Deserialize, Serialize};
use serde_with::{DisplayFromStr, serde_as};

#[cfg(feature = "example-skip-defaults")]
fn is_default<T: Default + PartialEq>(t: &T) -> bool {
    t == &T::default()
}

/// Entry point to a BLIPlab song. Made of BLIP channels.
#[derive(new, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Song<'a> {
    #[serde(default)]
    #[cfg_attr(
        feature = "example-skip-defaults",
        serde(skip_serializing_if = "is_default")
    )]
    global_variables: Globals,
    #[new(into_iter = "(Cow<'a, str>, Channel<'a>)")]
    channels: HashMap<Cow<'a, str>, Channel<'a>>,
}

/// Global variables used by the compiler for rendering every sample.
/// They are made global for the sake of consistency but can be modified.
#[derive(new, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct Globals {
    #[new(into)]
    absolute_length: char,
    #[new(into)]
    note_index: char,
}

impl Default for Globals {
    fn default() -> Self {
        Self::new('L', 'n')
    }
}

/// BLIP channel. Contains a song for just one instrument.
#[serde_as]
#[derive(new, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Channel<'a> {
    input: PathOrString<'a>,
    #[new(into_iter = "Cow<'a, str>")]
    notes: Vec<Cow<'a, str>>,
    #[serde_as(as = "DisplayFromStr")]
    instrument: Expression,
    #[new(into_iter = "(char, f64)")]
    #[serde(default)]
    #[cfg_attr(
        feature = "example-skip-defaults",
        serde(skip_serializing_if = "is_default")
    )]
    variables: HashMap<char, f64>,
    #[new(into_iter = "(char, Cow<'a, str>)")]
    #[serde(default)]
    #[cfg_attr(
        feature = "example-skip-defaults",
        serde(skip_serializing_if = "is_default")
    )]
    macros: HashMap<char, Cow<'a, str>>,
    #[new(into_iter = "(Cow<'a, str>, VariableChange)")]
    #[serde(default = "default_slope")]
    slopes: HashMap<Cow<'a, str>, VariableChange>,
}

fn default_slope<'a>() -> HashMap<Cow<'a, str>, VariableChange> {
    [(
        "L".into(),
        VariableChange::new(
            'L',
            "2^(2-log(2, l))*(60/T)"
                .parse()
                .expect("oops, my default length expression doesn't work"),
        ),
    )]
    .into()
}

/// Same as [bliplib::compiler::VariableChange] but with named fields and serde support.
/// Both types are compatible with [From].
#[serde_as]
#[derive(new, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct VariableChange {
    target: char,
    #[serde_as(as = "DisplayFromStr")]
    change: Expression,
}

impl From<bliplib::compiler::VariableChange> for VariableChange {
    fn from(value: bliplib::compiler::VariableChange) -> Self {
        Self {
            target: value.0,
            change: value.1,
        }
    }
}

impl From<VariableChange> for bliplib::compiler::VariableChange {
    fn from(value: VariableChange) -> Self {
        Self(value.target, value.change)
    }
}

/// BLIP [Channel] MML input, either a file or a string.
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
#[serde(deny_unknown_fields)]
pub enum PathOrString<'a> {
    /// Read the MML from a BLIP file.
    Path(PathBuf),
    /// Read the MML from the specified string.
    String(Cow<'a, str>),
}