poc/poc.yml

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

src/bng.rs

@@ -6,7 +6,6 @@ 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};
@@ -66,16 +65,15 @@ impl FromStr for Expression {
     }
 }
 
-#[derive(new, Deserialize)]
+#[derive(new)]
-#[cfg_attr(debug_assertions, derive(Serialize, Debug))]
+#[cfg_attr(debug_assertions, derive(Serialize))]
 pub(super) struct Channel {
     instr: String,
-    score: Atoms,
+    score: Vec<Atom>,
 }
 
-#[derive(Deserialize)]
+#[cfg_attr(debug_assertions, derive(new, Serialize))]
-#[cfg_attr(debug_assertions, derive(new, Debug, Serialize))]
 pub(super) struct BngFile {
-    instruments: HashMap<String, Instrument>,
+    instruments: Vec<HashMap<String, Instrument>>,
     channels: HashMap<String, Channel>,
 }

src/bng/instrument.rs

@@ -2,14 +2,13 @@ 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, Deserialize)]
+#[derive(Deref, new)]
-#[cfg_attr(debug_assertions, derive(Serialize, Debug))]
+#[cfg_attr(debug_assertions, derive(Serialize))]
 pub struct Instrument {
     #[target]
     expr: Instruction,

src/bng/score.rs

@@ -1,117 +1,16 @@
 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, space1, u16, u8},
+    character::complete::{anychar, char, one_of, u16, u8},
     combinator::{map_opt, map_res, opt, value, verify},
     multi::many0,
     sequence::{delimited, pair, preceded, separated_pair, terminated},
@@ -38,9 +38,7 @@ impl Parse for Modifier {
     }
 }
 
-pub fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::Error<&str>> {
+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)),
@@ -68,9 +66,8 @@ pub fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::
                     SlopeModifier::parse,
                     char(' '),
                     map_res(take_till1(|c| c == ','), |s: &str| {
-                            s.parse().map_err(|_| {
+                        s.parse()
-                                nom::error::Error::new(s, nom::error::ErrorKind::Verify)
+                            .map_err(|_| nom::error::Error::new(s, nom::error::ErrorKind::Verify))
-                            })
                     }),
                 ),
             ),
@@ -86,6 +83,5 @@ pub fn flat_atom_parser(notes: &str) -> impl Parser<&str, FlatAtom, nom::error::
                 char(Atom::COMMENT.1),
             ),
         ),
-        )),
+    ))
-    )
 }

src/bng/score/utils.rs

@@ -7,7 +7,7 @@ mod tests;
 
 #[derive(Debug, EnumDiscriminants)]
 #[strum_discriminants(derive(Display))]
-pub enum Wrapper {
+enum Wrapper {
     Loop(NonZeroU8),
     Tuple,
     Slope(SlopeModifier, Instruction),
@@ -15,12 +15,12 @@ pub enum Wrapper {
 
 #[derive(Debug, Error)]
 #[cfg_attr(test, derive(PartialEq))]
-pub enum InflateError {
+enum InflateError {
     #[error("misplaced {0} end symbol")]
     MismatchedEnd(WrapperDiscriminants),
 }
 
-pub fn inflate(mut flat_atoms: Vec<FlatAtom>) -> Result<Vec<Atom>, InflateError> {
+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,41 +12,29 @@ mod cli;
 fn main() -> Result<(), serde_yml::Error> {
     // println!("{}", option_env!("TEST").unwrap_or("ok"));
     let args = Cli::parse();
-    // #[cfg(debug_assertions)]
+    println!(
-    // {
+        "{}",
-    //     println!("{}", serde_yml::to_string(&bngfile_generator())?);
+        serde_yml::to_string(&BngFile::new(
-    //     println!("{:?}", args);
+            vec![HashMap::from([
-    // }
-    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![].into()),
+                Channel::new("sine".to_string(), vec![])
-        )]),
+            )])
-    )
+        ))?
+    );
+    #[cfg(debug_assertions)]
+    println!("{:?}", args);
+    Ok(())
 }