chore: Merge branch 'release/0.6.0'

Author: Ben Leadbetter

CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.5.4
+* feat: generate MIDI CI messages
+    * strongly typed MIDI CI version
+    * implement MIDI CI discovery
+* fix: fixes sysex next impl broken with 'empty' packets
+* fix: some clippy warnings
+* refactor!: ci is no longer a default feature
+* refactor!: rename `note` properties to `note_number`
+* refactor!: `pitch7_9` and `pitch7_25` used fixed number type
+    * pull in `fixed` crate
+
 # 0.5.4
 * ci: update remote repo url to midi2-dev
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "midi2"
-version = "0.5.4"
+version = "0.6.0"
 description = "Ergonomic, versatile, strong types wrapping MIDI 2.0 message data."
 edition = "2021"
 readme = "README.md"
@@ -21,7 +21,8 @@ name = "midi2"
 path = "src/lib.rs" 
 
 [features]
-default = ["std", "ci", "channel-voice2"]
+default = ["std", "channel-voice2"]
+# wip
 ci = ["sysex7"]
 flex-data = []
 channel-voice1 = []
@@ -35,7 +36,8 @@ utility = []
 
 [dependencies]
 derive_more = { version = "0.99.17", features = ["from"], default-features = false }
-midi2_proc = { version = "0.5.4", path = "midi2_proc" }
+fixed = "1.27.0"
+midi2_proc = { version = "0.6.0", path = "midi2_proc" }
 ux = "0.1.6"
 
 [dev-dependencies]

README.md

@@ -26,12 +26,12 @@ use midi2::prelude::*;
 let mut note_on = channel_voice2::NoteOn::<[u32; 4]>::new();
 note_on.set_group(u4::new(0x8));
 note_on.set_channel(u4::new(0xA));
-note_on.set_note(u7::new(0x5E));
+note_on.set_note_number(u7::new(0x5E));
 note_on.set_velocity(0x6A14);
 
 assert_eq!(note_on.group(), u4::new(0x8));
 assert_eq!(note_on.channel(), u4::new(0xA));
-assert_eq!(note_on.note(), u7::new(0x5E));
+assert_eq!(note_on.note_number(), u7::new(0x5E));
 assert_eq!(note_on.velocity(), 0x6A14);
 
 // Messages wrap an underlying buffer of data which can be read as an
@@ -69,10 +69,10 @@ fn handle_message(buffer: &[u32]) {
             println!("Channel Voice2: channel: {}", m.channel());
             match m {
                 channel_voice2::ChannelVoice2::NoteOn(m) => {
-                    println!("Note On! note: {}, velocity: {}", m.note(), m.velocity());
+                    println!("Note On! note: {}, velocity: {}", m.note_number(), m.velocity());
                 }
                 channel_voice2::ChannelVoice2::NoteOff(m) => {
-                    println!("Note Off! note: {}, velocity: {}", m.note(), m.velocity());
+                    println!("Note Off! note: {}, velocity: {}", m.note_number(), m.velocity());
                 }
                 _ => {}
             }
@@ -156,7 +156,7 @@ You'll want to setup midi2 without default features to compile
 without the `std` feature.
 
 ```toml
-midi2 = { version = "0.5.4", default-features = false, features = ["channel-voice2", "sysex7"],  }
+midi2 = { version = "0.6.0", default-features = false, features = ["channel-voice2", "sysex7"],  }
 ```
 
 ### Generic Representation

examples/handling_messages.rs

@@ -6,14 +6,23 @@ fn handle_message(buffer: &[u32]) {
             println!("Channel Voice2: channel: {}", m.channel());
             match m {
                 channel_voice2::ChannelVoice2::NoteOn(m) => {
-                    println!("Note On! note: {}, velocity: {}", m.note(), m.velocity());
+                    println!(
+                        "Note On! note: {}, velocity: {}",
+                        m.note_number(),
+                        m.velocity()
+                    );
                 }
                 channel_voice2::ChannelVoice2::NoteOff(m) => {
-                    println!("Note Off! note: {}, velocity: {}", m.note(), m.velocity());
+                    println!(
+                        "Note Off! note: {}, velocity: {}",
+                        m.note_number(),
+                        m.velocity()
+                    );
                 }
                 _ => {}
             }
         }
+        #[cfg(feature = "sysex7")]
         Ok(UmpMessage::Sysex7(m)) => {
             println!(
                 "Sysex 7bit: payload: {:?}",

fuzz/fuzz_targets/sysex8_payload_roundtrip.rs

@@ -9,7 +9,7 @@ fuzz_target!(|data: &[u8]| {
 
     // payload is unchanged
     let payload = message.payload().collect::<Vec<u8>>();
-    assert_eq!(payload, data.iter().cloned().collect::<Vec<u8>>());
+    assert_eq!(payload, data.to_vec());
 
     // message is in a valid state
     let mut buffer = Vec::new();

midi2_proc/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "midi2_proc"
 description = "Internal procedural macro crate. Only intended for use with midi2"
-version = "0.5.4"
+version = "0.6.0"
 edition = "2021"
 readme = "README.md"
 license = "MIT OR Apache-2.0"

midi2_proc/src/common.rs

@@ -31,6 +31,50 @@ impl BufferGeneric {
     }
 }
 
+pub fn has_attr(field: &syn::Field, id: &str) -> bool {
+    field.attrs.iter().any(|attr| {
+        let syn::Meta::Path(path) = &attr.meta else {
+            return false;
+        };
+        path.segments
+            .last()
+            .iter()
+            .any(|&segment| segment.ident == id)
+    })
+}
+
+pub fn meta_type(field: &syn::Field) -> syn::Type {
+    field
+        .attrs
+        .iter()
+        .filter_map(|attr| {
+            use syn::Meta::*;
+            match &attr.meta {
+                List(list) => Some(list),
+                _ => None,
+            }
+        })
+        .find(|list| {
+            list.path
+                .segments
+                .last()
+                .iter()
+                .any(|&segment| segment.ident == "property")
+        })
+        .map(|list| {
+            list.parse_args::<syn::Type>()
+                .expect("Arguments to property attribute should be a valid type")
+        })
+        .expect("fields must be annotated with the property attribute")
+}
+
+pub fn is_unit_tuple(ty: &syn::Type) -> bool {
+    match ty {
+        syn::Type::Tuple(tup) => tup.elems.is_empty(),
+        _ => false,
+    }
+}
+
 pub fn buffer_generic(generics: &syn::Generics) -> Option<BufferGeneric> {
     let type_param = |param: &syn::GenericParam| {
         if let syn::GenericParam::Type(type_param) = param {
@@ -46,41 +90,52 @@ pub fn buffer_generic(generics: &syn::Generics) -> Option<BufferGeneric> {
             None
         }
     };
-    let buffer_bound = |id: &'static str| {
-        move |bound: &syn::TraitBound| match bound.path.segments.last().as_ref() {
+    let is_buffer_bound = |id: &'static str| {
+        move |bound: syn::TraitBound| match bound.path.segments.last().as_ref() {
             Some(segment) => segment.ident == id,
             None => false,
         }
     };
     for param in generics.params.iter().filter_map(type_param) {
-        if let Some(_) = param
+        if param
             .bounds
             .iter()
             .filter_map(trait_bound)
-            .find(buffer_bound("Ump"))
+            .any(is_buffer_bound("Ump"))
         {
             return Some(BufferGeneric::Ump(param.clone()));
         };
-        if let Some(_) = param
+        if param
             .bounds
             .iter()
             .filter_map(trait_bound)
-            .find(buffer_bound("Bytes"))
+            .any(is_buffer_bound("Bytes"))
         {
             return Some(BufferGeneric::Bytes(param.clone()));
         };
-        if let Some(_) = param
+        if param
             .bounds
             .iter()
             .filter_map(trait_bound)
-            .find(buffer_bound("Buffer"))
+            .any(is_buffer_bound("Buffer"))
         {
             return Some(BufferGeneric::UmpOrBytes(param.clone()));
         };
     }
     None
 }
 
+pub fn std_only_attribute(is_std_only: bool) -> TokenStream {
+    if is_std_only {
+        quote! {
+            #[cfg(feature = "std")]
+            #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+        }
+    } else {
+        TokenStream::new()
+    }
+}
+
 pub fn rebuffer_generics(repr: Representation) -> TokenStream {
     match repr {
         Representation::Ump => quote! {
@@ -146,3 +201,18 @@ pub fn try_rebuffer_generics(repr: Representation) -> TokenStream {
         },
     }
 }
+
+pub fn parse_via_args(input: syn::parse::ParseStream) -> syn::Type {
+    let syn::ExprParen { expr, .. } = input
+        .parse()
+        .expect("Bracketed expression should follow size arg");
+
+    let syn::Expr::Path(path) = *expr else {
+        panic!("Via argument should contain a path type");
+    };
+
+    syn::Type::Path(syn::TypePath {
+        qself: path.qself,
+        path: path.path,
+    })
+}

midi2_proc/src/derives.rs

@@ -375,16 +375,20 @@ pub fn debug(item: TokenStream1) -> TokenStream1 {
         _ => panic!("Only enums and structs supported"),
     };
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-    let buffer_id = common::buffer_generic(&generics)
+    let buffer_id = common::buffer_generic(generics)
         .expect("Expected buffer generic")
         .ident();
     quote! {
         impl #impl_generics core::fmt::Debug for #ident #ty_generics #where_clause {
             fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+                use crate::BufferAccess as BufferAccessDeriveDebug;
+
                 fmt.write_fmt(format_args!("{}([", stringify!(#ident)))?;
                 match <<#buffer_id as crate::buffer::Buffer>::Unit as crate::buffer::UnitPrivate>::UNIT_ID {
                     crate::buffer::UNIT_ID_U8 => {
-                        let buff = self.0.buffer();
+                        use crate::buffer::SpecialiseU8 as SpecialiseU8DeriveDebug;
+
+                        let buff = self.buffer_access();
                         let mut iter = buff.specialise_u8().iter().peekable();
                         while let Some(v) = iter.next() {
                             fmt.write_fmt(format_args!("{:#04X}", v))?;
@@ -394,7 +398,9 @@ pub fn debug(item: TokenStream1) -> TokenStream1 {
                         }
                     }
                     crate::buffer::UNIT_ID_U32 => {
-                        let buff = self.0.buffer();
+                        use crate::buffer::SpecialiseU32 as SpecialiseU32DeriveDebug;
+
+                        let buff = self.buffer_access();
                         let mut iter = buff.specialise_u32().iter().peekable();
                         while let Some(v) = iter.next() {
                             fmt.write_fmt(format_args!("{:#010X}", v))?;