serialize everything

poc/poc.yml

@@ -14,6 +14,8 @@ channels:
   melody:
     instr: sine
     score:
+      notes: cCdDefFgGaAb
+      sheet:
         aabc.
         'rt°y
         +d+d+d---

src/bng.rs

@@ -6,6 +6,7 @@ use derived_deref::Deref;
 use fasteval::{Compiler, Instruction};
 pub(super) use instrument::Instrument;
 pub(super) use score::Atom;
+use score::Atoms;
 #[cfg(debug_assertions)]
 use serde::Serialize;
 use serde::{de::Visitor, Deserialize};
@@ -65,15 +66,16 @@ impl FromStr for Expression {
     }
 }
 
-#[derive(new)]
+#[derive(new, Deserialize)]
-#[cfg_attr(debug_assertions, derive(Serialize))]
+#[cfg_attr(debug_assertions, derive(Serialize, Debug))]
 pub(super) struct Channel {
     instr: String,
-    score: Vec<Atom>,
+    score: Atoms,
 }
 
-#[cfg_attr(debug_assertions, derive(new, Serialize))]
+#[derive(Deserialize)]
+#[cfg_attr(debug_assertions, derive(new, Debug, Serialize))]
 pub(super) struct BngFile {
-    instruments: Vec<HashMap<String, Instrument>>,
+    instruments: HashMap<String, Instrument>,
     channels: HashMap<String, Channel>,
 }

src/bng/instrument.rs

@@ -2,13 +2,14 @@ use std::collections::HashMap;
 
 use derive_new::new;
 use derived_deref::Deref;
+use serde::Deserialize;
 #[cfg(debug_assertions)]
 use serde::Serialize;
 
 use super::Expression as Instruction;
 
-#[derive(Deref, new)]
+#[derive(Deref, new, Deserialize)]
-#[cfg_attr(debug_assertions, derive(Serialize))]
+#[cfg_attr(debug_assertions, derive(Serialize, Debug))]
 pub struct Instrument {
     #[target]
     expr: Instruction,

src/bng/score.rs

@@ -1,16 +1,117 @@
 use std::num::{NonZeroU16, NonZeroU8};
 
+use amplify::From;
 use anyhow::Context;
 use bng_macros::{QuickModifierParser, SlopeModifierParser};
+use derive_new::new;
+use derived_deref::Deref;
+use lex::lexer::flat_atom_parser;
+use nom::multi::many0;
 #[cfg(debug_assertions)]
 use serde::Serialize;
+use serde::{
+    de::{self, Visitor},
+    Deserialize,
+};
 use strum::EnumDiscriminants;
+use thiserror::Error;
+use utils::{inflate, InflateError};
 
 mod lex;
 mod utils;
 
 use super::Expression as Instruction;
 
+#[derive(Deref, From)]
+#[cfg_attr(debug_assertions, derive(Serialize, Debug))]
+pub struct Atoms(Vec<Atom>);
+
+#[derive(Debug, Error)]
+enum AtomsSerializeError {
+    #[error("error while parsing with nom")]
+    Parsing(String),
+    #[error("error while inflating flat atoms")]
+    Inflation(#[from] InflateError),
+}
+
+impl<'de> Deserialize<'de> for Atoms {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "lowercase")]
+        enum Field {
+            Notes,
+            Sheet,
+        }
+        #[derive(Deserialize, new)]
+        struct NotesSheet {
+            notes: String,
+            sheet: String,
+        }
+        struct NotesSheetVisitor;
+        impl<'de> Visitor<'de> for NotesSheetVisitor {
+            type Value = NotesSheet;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a \"notes\" field and a \"sheet\" field")
+            }
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let notes = seq
+                    .next_element()?
+                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
+                let sheet = seq
+                    .next_element()?
+                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
+                Ok(NotesSheet::new(notes, sheet))
+            }
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                let mut notes = None;
+                let mut sheet = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Notes => {
+                            if notes.is_some() {
+                                return Err(de::Error::duplicate_field("notes"));
+                            }
+                            notes = Some(map.next_value()?);
+                        }
+                        Field::Sheet => {
+                            if sheet.is_some() {
+                                return Err(de::Error::duplicate_field("sheet"));
+                            }
+                            sheet = Some(map.next_value()?);
+                        }
+                    }
+                }
+                let notes = notes.ok_or_else(|| de::Error::missing_field("notes"))?;
+                let sheet = sheet.ok_or_else(|| de::Error::missing_field("sheet"))?;
+                Ok(NotesSheet::new(notes, sheet))
+            }
+        }
+        const FIELDS: &[&str] = &["notes", "sheet"];
+        let NotesSheet { notes, sheet } =
+            deserializer.deserialize_struct("NotesSheet", FIELDS, NotesSheetVisitor)?;
+        let x = many0(flat_atom_parser(&notes))(&sheet)
+            .map_err(|e| e.to_string())
+            .map_err(AtomsSerializeError::Parsing)
+            .map_err(de::Error::custom)
+            .and_then(|(_, v)| {
+                inflate(v)
+                    .map_err(AtomsSerializeError::from)
+                    .map_err(de::Error::custom)
+            })
+            .map(Atoms);
+        x
+    }
+}
+
 #[cfg_attr(debug_assertions, derive(Debug, PartialEq))]
 pub enum Atom {
     Note(u8),

src/bng/score/lex/lexer.rs

@@ -8,7 +8,7 @@ use fasteval::Compiler;
 use nom::{
     branch::alt,
     bytes::complete::{take_till, take_till1},
-    character::complete::{anychar, char, one_of, u16, u8},
+    character::complete::{anychar, char, one_of, space1, u16, u8},
     combinator::{map_opt, map_res, opt, value, verify},
     multi::many0,
     sequence::{delimited, pair, preceded, separated_pair, terminated},
@@ -38,7 +38,9 @@ impl Parse for Modifier {
     }
 }
 
-fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::Error<&str>> {
+pub fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::Error<&str>> {
+    preceded(
+        many0(alt((char('\t'), char(' '), char('\n'), char('\r')))),
         alt((
             map_res(map_opt(one_of(notes), |c| notes.find(c)), u8::try_from).map(FlatAtom::Note),
             value(FlatAtom::Rest, char(Atom::REST)),
@@ -66,8 +68,9 @@ fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::Erro
                         SlopeModifier::parse,
                         char(' '),
                         map_res(take_till1(|c| c == ','), |s: &str| {
-                        s.parse()
+                            s.parse().map_err(|_| {
-                            .map_err(|_| nom::error::Error::new(s, nom::error::ErrorKind::Verify))
+                                nom::error::Error::new(s, nom::error::ErrorKind::Verify)
+                            })
                         }),
                     ),
                 ),
@@ -83,5 +86,6 @@ fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::Erro
                     char(Atom::COMMENT.1),
                 ),
             ),
-    ))
+        )),
+    )
 }

src/bng/score/utils.rs

@@ -7,7 +7,7 @@ mod tests;
 
 #[derive(Debug, EnumDiscriminants)]
 #[strum_discriminants(derive(Display))]
-enum Wrapper {
+pub enum Wrapper {
     Loop(NonZeroU8),
     Tuple,
     Slope(SlopeModifier, Instruction),
@@ -15,12 +15,12 @@ enum Wrapper {
 
 #[derive(Debug, Error)]
 #[cfg_attr(test, derive(PartialEq))]
-enum InflateError {
+pub enum InflateError {
     #[error("misplaced {0} end symbol")]
     MismatchedEnd(WrapperDiscriminants),
 }
 
-fn inflate(mut flat_atoms: Vec<FlatAtom>) -> Result<Vec<Atom>, InflateError> {
+pub fn inflate(mut flat_atoms: Vec<FlatAtom>) -> Result<Vec<Atom>, InflateError> {
     type Error = InflateError;
     let mut result = Vec::with_capacity(flat_atoms.len());
     let mut loop_stack: Vec<Vec<Atom>> = Vec::new();

src/main.rs

@@ -12,29 +12,41 @@ mod cli;
 fn main() -> Result<(), serde_yml::Error> {
     // println!("{}", option_env!("TEST").unwrap_or("ok"));
     let args = Cli::parse();
-    println!(
+    // #[cfg(debug_assertions)]
-        "{}",
+    // {
-        serde_yml::to_string(&BngFile::new(
+    //     println!("{}", serde_yml::to_string(&bngfile_generator())?);
-            vec![HashMap::from([
+    //     println!("{:?}", args);
+    // }
+    match args {
+        Cli::Play(PlayOpts { input }) => {
+            let bng_file: BngFile = serde_yml::from_str(&input)?;
+            #[cfg(debug_assertions)]
+            println!("{:?}", bng_file);
+        }
+        _ => unimplemented!("can't do that yet"),
+    }
+    Ok(())
+}
+
+#[cfg(debug_assertions)]
+fn bngfile_generator() -> BngFile {
+    BngFile::new(
+        HashMap::from([
             (
                 "sine".to_string(),
-                    Instrument::new("sin(2*PI*f*t)".parse().unwrap(), None)
+                Instrument::new("sin(2*PI*f*t)".parse().unwrap(), None),
             ),
             (
                 "square".to_string(),
                 Instrument::new(
                     "v*abs(sin(2*PI*f*t))".parse().unwrap(),
-                        Some(HashMap::from([("v".to_string(), 1f32)]))
+                    Some(HashMap::from([("v".to_string(), 1f32)])),
-                    )
+                ),
-                )
+            ),
-            ])],
+        ]),
         HashMap::<String, Channel>::from([(
             "melody".to_string(),
-                Channel::new("sine".to_string(), vec![])
+            Channel::new("sine".to_string(), vec![].into()),
-            )])
+        )]),
-        ))?
+    )
-    );
-    #[cfg(debug_assertions)]
-    println!("{:?}", args);
-    Ok(())
 }