Run cargo fmt and check formatting in CI

.github/workflows/ci.yml

@@ -47,6 +47,9 @@ jobs:
         with:
           cache-all-crates: true
 
+      - name: Check format
+        run: cargo fmt --all -- --check
+
       - name: Setup Linux dependencies
         if: runner.os == 'Linux' && matrix.setup != 'linux-aarch64' && matrix.setup != 'wasm' && matrix.setup != 'android'
         run: |

src/backend/alsa/mod.rs

@@ -7,7 +7,7 @@ use crate::{errors, Ignore, MidiMessage};
 use alsa::seq::{Addr, EventType, PortCap, PortInfo, PortSubscribe, PortType, QueueTempo};
 use alsa::{Direction, Seq};
 
-use log::{error, debug, log_enabled, Level};
+use log::{debug, error, log_enabled, Level};
 
 use errors::*;
 
@@ -178,7 +178,9 @@ impl PipeFd {
 
 impl Drop for PipeFd {
     fn drop(&mut self) {
-        unsafe { libc::close(self.0); }
+        unsafe {
+            libc::close(self.0);
+        }
     }
 }
 
@@ -230,9 +232,7 @@ impl MidiInput {
         let mut queue_id = 0;
         // Create the input queue
         if !cfg!(feature = "avoid_timestamping") {
-            queue_id = seq
-                .alloc_named_queue(c"midir queue")
-                .unwrap();
+            queue_id = seq.alloc_named_queue(c"midir queue").unwrap();
             // Set arbitrary tempo (mm=100) and resolution (240)
             let qtempo = QueueTempo::empty().unwrap();
             qtempo.set_tempo(600_000);
@@ -481,7 +481,10 @@ impl<T> MidiInputConnection<T> {
         // Request the thread to stop.
         let _res = unsafe {
             libc::write(
-                self.trigger_send_fd.as_ref().expect("send_fd already taken").get(),
+                self.trigger_send_fd
+                    .as_ref()
+                    .expect("send_fd already taken")
+                    .get(),
                 &false as *const bool as *const _,
                 mem::size_of::<bool>() as libc::size_t,
             )
@@ -704,9 +707,10 @@ impl MidiOutputConnection {
         assert!(nbytes <= u32::MAX as usize);
 
         if nbytes > self.coder.get_buffer_size() as usize
-            && self.coder.resize_buffer(nbytes as u32).is_err() {
-                return Err(SendError::Other("could not resize ALSA encoding buffer"));
-            }
+            && self.coder.resize_buffer(nbytes as u32).is_err()
+        {
+            return Err(SendError::Other("could not resize ALSA encoding buffer"));
+        }
 
         let mut ev = match self.coder.get_wrapped().encode(message) {
             Ok((_, Some(ev))) => ev,
@@ -834,7 +838,10 @@ fn handle_input<T>(mut data: HandlerData<T>, user_data: &mut T) -> HandlerData<T
                     continue;
                 }
                 Err(ref e) => {
-                    error!("Error in handle_input: unknown ALSA MIDI input error ({})!", e);
+                    error!(
+                        "Error in handle_input: unknown ALSA MIDI input error ({})!",
+                        e
+                    );
                     continue;
                 }
             };

src/backend/jack/mod.rs

@@ -235,9 +235,7 @@ extern "C" fn handle_input<T>(nframes: jack_nframes_t, arg: *mut c_void) -> i32
             let event = unsafe { event.assume_init() };
 
             for i in 0..event.size {
-                message
-                    .bytes
-                    .push(unsafe { *event.buffer.add(i) });
+                message.bytes.push(unsafe { *event.buffer.add(i) });
             }
 
             message.timestamp = Client::get_time(); // this is in microseconds
@@ -363,7 +361,8 @@ impl MidiOutput {
             .client
             .as_mut()
             .unwrap()
-            .connect(source_port.get_name(), &port.name).is_err()
+            .connect(source_port.get_name(), &port.name)
+            .is_err()
         {
             return Err(ConnectError::new(ConnectErrorKind::InvalidPort, self));
         }

src/backend/jack/wrappers.rs

@@ -55,8 +55,7 @@ impl Client {
     }
 
     pub fn open(name: &str, options: JackOpenOptions) -> Result<Client, ()> {
-        let c_name = CString::new(name)
-            .expect("client name must not contain null bytes");
+        let c_name = CString::new(name).expect("client name must not contain null bytes");
         let result = unsafe { jack_client_open(c_name.as_ptr(), options.bits(), ptr::null_mut()) };
         if result.is_null() {
             Err(())
@@ -89,8 +88,7 @@ impl Client {
     }
 
     pub fn register_midi_port(&mut self, name: &str, flags: PortFlags) -> Result<MidiPort, ()> {
-        let c_name = CString::new(name)
-            .expect("port name must not contain null bytes");
+        let c_name = CString::new(name).expect("port name must not contain null bytes");
         let result = unsafe {
             jack_port_register(
                 self.p,
@@ -169,8 +167,7 @@ impl<'a> Index<usize> for PortInfos<'a> {
 
     fn index(&self, index: usize) -> &Self::Output {
         let slice = self.get_c_name(index).to_bytes();
-        str::from_utf8(slice)
-            .expect("Error converting port name to UTF8")
+        str::from_utf8(slice).expect("Error converting port name to UTF8")
     }
 }