chore: Merge branch 'release/0.11.0'

Author: BenLeadbetter

.pre-commit-config.yaml

@@ -10,7 +10,7 @@ repos:
   - id: conventional-pre-commit
     stages: [commit-msg]
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v5.0.0
+  rev: v6.0.0
   hooks:
   - id: check-added-large-files
     stages: [pre-commit]

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.11.0](https://github.com/midi2-dev/bl-midi2-rs/compare/0.10.0..0.11.0) - 2025-08-21
+
+### ✨ Features
+
+- *(sysex)* Splicing payload data - ([3ce414c](https://github.com/midi2-dev/bl-midi2-rs/commit/3ce414c4576f82497518f5a8c7396126b628ea6d))
+
+### 🐛 Fixes
+
+- Include trailing reserved bytes - ([6e224a9](https://github.com/midi2-dev/bl-midi2-rs/commit/6e224a92c9aab5595aa12a373b2996a831f33bdd))
+- Further clippy warnings - ([8bbee8b](https://github.com/midi2-dev/bl-midi2-rs/commit/8bbee8ba8932b13aa018befd98e88a6f8e0c68d1))
+- Readme file link - ([eaa0c41](https://github.com/midi2-dev/bl-midi2-rs/commit/eaa0c41e24c8e1f70a8a1168d93705b14e722907))
+
 ## [0.10.0](https://github.com/midi2-dev/bl-midi2-rs/compare/0.9.0..0.10.0) - 2025-07-27
 
 ### 🐛 Fixes

README.md

@@ -18,7 +18,7 @@ for more details on the data protocol standard.
 > Expect breaking changes and bugs, and please report any issues you encounter.
 
 We would welcome contributions! 
-Please refer to the [CONTRIBUTOR.md](CONTRIBUTOR.md)
+Please refer to the [CONTRIBUTING.md](CONTRIBUTING.md)
 
 ## Strongly Typed Message Wrappers
 

examples/handling_messages/src/main.rs

@@ -29,7 +29,7 @@ fn handle_message(buffer: &[u32]) {
             );
         }
         Err(e) => {
-            println!("Error parsing ump buffer: {:?}", e);
+            println!("Error parsing ump buffer: {e:?}");
         }
         _ => {}
     }

examples/no_std_dynamic_message_generator/src/main.rs

@@ -67,7 +67,7 @@ impl Generator {
         }
     }
 
-    fn generate(&mut self) -> Result<MessageIterator, midi2::error::BufferOverflow> {
+    fn generate(&mut self) -> Result<MessageIterator<'_>, midi2::error::BufferOverflow> {
         let mut number_of_messages = 0;
         let buffer = &mut self.buffer[..];
 
@@ -113,6 +113,6 @@ impl Generator {
 fn main() {
     let mut generator = Generator::new();
     for message in generator.generate().unwrap() {
-        std::println!("{:?}", message);
+        std::println!("{message:?}");
     }
 }

fuzz/Cargo.toml

@@ -38,8 +38,8 @@ doc = false
 bench = false
 
 [[bin]]
-name = "generic_sysex_inserting_payloads"
-path = "./fuzz_targets/generic_sysex_inserting_payloads.rs"
+name = "generic_sysex_splicing_payloads"
+path = "./fuzz_targets/generic_sysex_splicing_payloads.rs"
 test = false
 doc = false
 bench = false

…gets/generic_sysex_inserting_payloads.rs …rgets/generic_sysex_splicing_payloads.rsfuzz/fuzz_targets/generic_sysex_inserting_payloads.rs renamed to fuzz/fuzz_targets/generic_sysex_splicing_payloads.rs fuzz/fuzz_targets/generic_sysex_inserting_payloads.rs renamed to fuzz/fuzz_targets/generic_sysex_splicing_payloads.rs

@@ -59,12 +59,13 @@ impl IntoByte<u8> for u8 {
     }
 }
 
-fn test_case<B, M>(data: &InputData, mut message: M, index: usize)
+fn test_case<B, M, R>(data: &InputData, mut message: M, range: R)
 where
     B: midi2::buffer::Buffer + midi2::buffer::BufferTryResize + midi2::buffer::BufferMut,
     M: midi2::Sysex<B>,
     <M as Sysex<B>>::Byte: Eq + core::fmt::Debug,
     u8: IntoByte<<M as Sysex<B>>::Byte>,
+    R: core::ops::RangeBounds<usize> + Clone,
 {
     let Ok(()) = message.try_set_payload(data.initial_data.iter().map(u8::byte)) else {
         return;
@@ -78,14 +79,16 @@ where
         );
     }
 
-    let Ok(()) = message.try_insert_payload(data.data_to_insert.iter().map(u8::byte), index) else {
+    let Ok(()) =
+        message.try_splice_payload(data.data_to_insert.iter().map(u8::byte), range.clone())
+    else {
         return;
     };
 
     let actual = message.payload().collect::<Vec<_>>();
     let expected = {
         let mut ret = data.initial_data.clone();
-        ret.splice(index..index, data.data_to_insert.clone());
+        ret.splice(range, data.data_to_insert.clone());
         ret.iter().map(u8::byte).collect::<Vec<_>>()
     };
     assert_eq!(actual, expected);
@@ -94,33 +97,41 @@ where
 fuzz_target!(|data: InputData| {
     let mut rng = rand::rngs::StdRng::seed_from_u64(data.seed);
     let fized_size_buffer_size = rng.random_range(4..MAX_BUFFER_SIZE);
-    let index = if data.initial_data.is_empty() {
-        0
-    } else {
-        rng.random_range(0..data.initial_data.len())
+    let range = {
+        if data.initial_data.is_empty() {
+            0..0
+        } else {
+            let lower = rng.random_range(0..data.initial_data.len());
+            if lower == data.initial_data.len() {
+                lower..lower
+            } else {
+                let upper = rng.random_range(lower..data.initial_data.len());
+                lower..upper
+            }
+        }
     };
     test_case(
         &data,
         midi2::sysex8::Sysex8::<FixedSizeBuffer<u32>>::try_new_with_buffer(
             FixedSizeBuffer::<u32>::new(fized_size_buffer_size),
         )
         .unwrap(),
-        index,
+        range.clone(),
     );
     test_case(
         &data,
         midi2::sysex7::Sysex7::<FixedSizeBuffer<u32>>::try_new_with_buffer(
             FixedSizeBuffer::<u32>::new(fized_size_buffer_size),
         )
         .unwrap(),
-        index,
+        range.clone(),
     );
     test_case(
         &data,
         midi2::sysex7::Sysex7::<FixedSizeBuffer<u8>>::try_new_with_buffer(
             FixedSizeBuffer::<u8>::new(fized_size_buffer_size),
         )
         .unwrap(),
-        index,
+        range.clone(),
     );
 });

midi2/src/channel_voice2/per_note_management.rs

@@ -9,7 +9,7 @@ pub(crate) const STATUS: u8 = 0b1111;
 /// MIDI 2.0 Channel Voice Per Note Management Message
 ///
 /// See the [module docs](crate::channel_voice2) for more info.
-#[midi2_proc::generate_message(Via(crate::channel_voice2::ChannelVoice2), FixedSize, MinSizeUmp(1))]
+#[midi2_proc::generate_message(Via(crate::channel_voice2::ChannelVoice2), FixedSize, MinSizeUmp(2))]
 struct PerNoteManagement {
     #[property(common_properties::UmpMessageTypeProperty<UMP_MESSAGE_TYPE>)]
     ump_type: (),
@@ -49,7 +49,7 @@ mod tests {
     #[test]
     fn note_number() {
         assert_eq!(
-            PerNoteManagement::try_from(&[0x4BF9_1C03][..])
+            PerNoteManagement::try_from(&[0x4BF9_1C03, 0x0][..])
                 .unwrap()
                 .note_number(),
             u7::new(0x1C),
@@ -58,14 +58,14 @@ mod tests {
 
     #[test]
     fn detach() {
-        assert!(PerNoteManagement::try_from(&[0x4BF9_1C03][..])
+        assert!(PerNoteManagement::try_from(&[0x4BF9_1C03, 0x0][..])
             .unwrap()
             .detach(),);
     }
 
     #[test]
     fn reset() {
-        assert!(PerNoteManagement::try_from(&[0x4BF9_1C03][..])
+        assert!(PerNoteManagement::try_from(&[0x4BF9_1C03, 0x0][..])
             .unwrap()
             .reset(),);
     }

midi2/src/detail/helpers.rs

@@ -89,16 +89,17 @@ pub fn validate_sysex_group_statuses<
     Ok(())
 }
 
-pub fn try_insert_sysex_data<
+pub fn try_splice_sysex_data<
     B: crate::buffer::Buffer + crate::buffer::BufferMut + crate::buffer::BufferTryResize,
     S: SysexInternal<B>,
     D: core::iter::Iterator<Item = <S as crate::traits::Sysex<B>>::Byte>,
+    R: core::ops::RangeBounds<usize>,
 >(
     sysex: &mut S,
     data: D,
-    before: usize,
+    range: R,
 ) -> core::result::Result<(), crate::error::BufferOverflow> {
-    match detail::try_insert_sysex_data(sysex, data, |s, sz| s.try_resize(sz), before) {
+    match detail::try_splice_sysex_data(sysex, data, |s, sz| s.try_resize(sz), range) {
         Err(e) => {
             // if the write failed we reset the message
             // back to zero data
@@ -111,23 +112,24 @@ pub fn try_insert_sysex_data<
     }
 }
 
-pub fn insert_sysex_data<
+pub fn splice_sysex_data<
     B: crate::buffer::Buffer + crate::buffer::BufferMut + crate::buffer::BufferResize,
     S: SysexInternal<B>,
     D: core::iter::Iterator<Item = <S as crate::traits::Sysex<B>>::Byte>,
+    R: core::ops::RangeBounds<usize>,
 >(
     sysex: &mut S,
     data: D,
-    before: usize,
+    range: R,
 ) {
-    detail::try_insert_sysex_data(
+    detail::try_splice_sysex_data(
         sysex,
         data,
         |s, sz| {
             s.resize(sz);
             Ok(())
         },
-        before,
+        range,
     )
     .expect("Resizable buffers should not fail here")
 }
@@ -137,23 +139,37 @@ mod detail {
 
     use super::*;
 
-    pub fn try_insert_sysex_data<
+    pub fn try_splice_sysex_data<
         B: crate::buffer::Buffer + crate::buffer::BufferMut,
         S: crate::traits::SysexInternal<B>,
         D: core::iter::Iterator<Item = <S as crate::traits::Sysex<B>>::Byte>,
         R: Fn(&mut S, usize) -> core::result::Result<(), SysexTryResizeError>,
+        Rg: core::ops::RangeBounds<usize>,
     >(
         sysex: &mut S,
         data: D,
         resize: R,
-        before: usize,
+        range: Rg,
     ) -> core::result::Result<(), crate::error::BufferOverflow> {
         // reformat first to ensure data is optimally filling the
         // underlying buffer
         sysex.compact();
 
         // get an initial estimate for the size of the data
         let initial_size = sysex.payload_size();
+
+        let splice_begin = match range.start_bound() {
+            core::ops::Bound::Included(&v) => v,
+            core::ops::Bound::Excluded(&v) => v + 1,
+            core::ops::Bound::Unbounded => 0,
+        };
+        let splice_end = match range.end_bound() {
+            core::ops::Bound::Included(&v) => v + 1,
+            core::ops::Bound::Excluded(&v) => v,
+            core::ops::Bound::Unbounded => initial_size,
+        };
+        let splice_size = splice_end - splice_begin;
+
         let mut running_data_size_estimate = match data.size_hint() {
             (_, Some(upper)) => upper,
             // not the optimal case - could lead to additional copying
@@ -163,27 +179,26 @@ mod detail {
         let mut additional_size_for_overflow = 1;
         let mut data = data.peekable();
 
-        // initial buffer resize
-        if let Err(SysexTryResizeError(sz)) =
-            resize(sysex, running_data_size_estimate + initial_size)
-        {
-            // failed. we'll work with what we've got
-            running_data_size_estimate = sz.saturating_sub(initial_size);
-        };
-
-        debug_assert_eq!(
-            sysex.payload_size(),
-            running_data_size_estimate + initial_size
-        );
+        if splice_end < splice_end + running_data_size_estimate - splice_size {
+            // we need to grow
+            // initial buffer resize
+            if let Err(SysexTryResizeError(sz)) = resize(
+                sysex,
+                running_data_size_estimate + initial_size - splice_size,
+            ) {
+                // failed. we'll work with what we've got
+                running_data_size_estimate = sz.saturating_sub(initial_size - splice_size);
+            };
+        }
 
-        let mut tail = before + running_data_size_estimate;
-        sysex.move_payload_tail(before, tail);
+        let mut tail = splice_end + running_data_size_estimate - splice_size;
+        sysex.move_payload_tail(splice_end, tail);
 
         'main: loop {
             while written < running_data_size_estimate {
                 match data.next() {
                     Some(v) => {
-                        sysex.write_datum(v, before + written);
+                        sysex.write_datum(v, splice_begin + written);
                         written += 1;
                     }
                     None => {
@@ -199,28 +214,41 @@ mod detail {
             }
 
             // we underestimated.
-            // resize to make more space
             running_data_size_estimate += additional_size_for_overflow;
-            if let Err(SysexTryResizeError(sz)) =
-                resize(sysex, running_data_size_estimate + initial_size)
+
             {
-                // failed. we'll work with what we've got
-                running_data_size_estimate = sz.saturating_sub(initial_size);
-            };
-            sysex.move_payload_tail(tail, before + running_data_size_estimate);
-            tail = before + running_data_size_estimate;
+                let mut to = splice_begin + running_data_size_estimate;
+                if tail < to {
+                    // we need to grow
+                    // resize to make more space
+                    // and move tail
+
+                    if let Err(SysexTryResizeError(sz)) = resize(
+                        sysex,
+                        running_data_size_estimate + initial_size - splice_size,
+                    ) {
+                        // failed. we'll work with what we've got
+                        running_data_size_estimate = sz.saturating_sub(initial_size - splice_size);
+                        to = splice_begin + running_data_size_estimate - splice_size;
+                    };
+                }
+
+                sysex.move_payload_tail(tail, to);
+                tail = splice_begin + running_data_size_estimate;
+            }
+
             additional_size_for_overflow *= 2;
 
             if written >= running_data_size_estimate {
                 return Err(BufferOverflow);
             }
         }
 
-        if written < running_data_size_estimate {
-            // we shrink the buffer back down to the correct size
-            sysex.move_payload_tail(tail, before + written);
-            resize(sysex, written + initial_size).map_err(|_| crate::error::BufferOverflow)?;
-        }
+        // we ensure the buffer is the correct size and move the tail
+        // to the final position
+        sysex.move_payload_tail(tail, splice_begin + written);
+        resize(sysex, written + initial_size - splice_size)
+            .map_err(|_| crate::error::BufferOverflow)?;
 
         Ok(())
     }