p6nj/bng
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

serialize everything (error on the sheet type)

Browse source
This commit is contained in:
Ponj 2024-10-31 00:21:24 -04:00
parent 9c6f76fd6e
commit 829cb64511
Signed by: p6nj
GPG key ID: 6FED68D87C479A59
7 changed files with 232 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
poc/poc.yml
View file

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

12
src/bng.rs
View file

@ -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)]
#[cfg_attr(debug_assertions, derive(Serialize))]
#[derive(new, Deserialize)]
#[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>,
}

5
src/bng/instrument.rs
View file

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

100
src/bng/score.rs
View file

@ -1,16 +1,116 @@
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<'a> {
notes: &'a str,
sheet: &'a str,
}
struct NotesSheetVisitor;
impl<'de> Visitor<'de> for NotesSheetVisitor {
type Value = NotesSheet<'de>;
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)?;
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)
}
}
#[cfg_attr(debug_assertions, derive(Debug, PartialEq))]
pub enum Atom {
Note(u8),

14
src/bng/score/lex/lexer.rs
View file

@ -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()
.map_err(|_| nom::error::Error::new(s, nom::error::ErrorKind::Verify))
s.parse().map_err(|_| {
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),
),
),
))
)),
)
}

6
src/bng/score/utils.rs
View file

@ -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();

44
src/main.rs
View file

@ -12,29 +12,41 @@ mod cli;
fn main() -> Result<(), serde_yml::Error> {
// println!("{}", option_env!("TEST").unwrap_or("ok"));
let args = Cli::parse();
println!(
"{}",
serde_yml::to_string(&BngFile::new(
vec![HashMap::from([
// #[cfg(debug_assertions)]
// {
// println!("{}", serde_yml::to_string(&bngfile_generator())?);
// 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![])
)])
))?
);
#[cfg(debug_assertions)]
println!("{:?}", args);
Ok(())
Channel::new("sine".to_string(), vec![].into()),
)]),
)
}