ci: Run "cargo fmt"

.github/workflows/rust.yml

@@ -24,10 +24,16 @@ jobs:
       with:
         toolchain: ${{ matrix.toolchain }}
 
+    - name: Format
+      # format always on stable, to avoid different toolchains pingponging
+      run: cargo +stable fmt --all --check
+
     - name: Build
       run: cargo +${{ matrix.toolchain }} build --workspace --verbose
+
     - name: Run tests
       run: cargo +${{ matrix.toolchain }} test --workspace --all-features --verbose -- --skip _runsinglethread
+
     - name: Run tests (single-threaded tests)
       run: cargo +${{ matrix.toolchain }} test --workspace --all-features --verbose -- _runsinglethread --test-threads 1
 
@@ -52,6 +58,7 @@ jobs:
         with:
           toolchain: ${{ matrix.toolchain }}
           target: aarch64-linux-android
+
       - name: Install toolchains (i686)
         uses: actions-rs/toolchain@v1
         with:
@@ -60,6 +67,7 @@ jobs:
 
       - name: cargo check (aarch64)
         run: cargo +${{ matrix.toolchain }} check --workspace --target aarch64-linux-android --all-features
+
       - name: cargo check (i686)
         run: cargo +${{ matrix.toolchain }} check --workspace --target i686-unknown-linux-gnu --all-features
 

procfs-core/src/process/mod.rs

@@ -499,7 +499,7 @@ impl crate::FromBufRead for MemoryMaps {
             match reader.read_line(&mut line) {
                 // End of file.
                 Ok(0) => break,
-                Ok(_) => {},
+                Ok(_) => {}
                 Err(_) => return Err(ProcError::Incomplete(None)),
             }
 

procfs/build.rs

@@ -2,7 +2,10 @@ fn main() {
     // Filters are extracted from `libc` filters
     let target_os = std::env::var("CARGO_CFG_TARGET_OS").expect("Missing CARGO_CFG_TARGET_OS envvar");
     if !["android", "linux", "l4re"].contains(&target_os.as_str()) {
-        eprintln!("Building {} on an for a unsupported platform. Currently only linux and android are supported", env!("CARGO_PKG_NAME"));
+        eprintln!(
+            "Building {} on an for a unsupported platform. Currently only linux and android are supported",
+            env!("CARGO_PKG_NAME")
+        );
         eprintln!("(Your current target_os is {})", target_os);
         std::process::exit(1)
     }

procfs/examples/lslocks.rs

@@ -5,7 +5,10 @@ use std::path::Path;
 fn main() {
     let myself = Process::myself().unwrap();
     let mountinfo = myself.mountinfo().unwrap();
-    println!("{:18}{:13}{:13}{:13}{:12} Path", "Process", "PID", "Lock Type", "Mode", "Kind");
+    println!(
+        "{:18}{:13}{:13}{:13}{:12} Path",
+        "Process", "PID", "Lock Type", "Mode", "Kind"
+    );
     println!("{}", "=".repeat(74));
     for lock in procfs::locks().unwrap() {
         lock.pid

procfs/examples/mounts.rs

@@ -1,11 +1,11 @@
 // List mountpoints listed in /proc/mounts
 
 fn main() {
-let width = 15;
+    let width = 15;
     for mount_entry in procfs::mounts().unwrap() {
         println!("Device: {}", mount_entry.fs_spec);
         println!("{:>width$}: {}", "Mount point", mount_entry.fs_file);
-        println!("{:>width$}: {}","FS type", mount_entry.fs_vfstype);
+        println!("{:>width$}: {}", "FS type", mount_entry.fs_vfstype);
         println!("{:>width$}: {}", "Dump", mount_entry.fs_freq);
         println!("{:>width$}: {}", "Check", mount_entry.fs_passno);
         print!("{:>width$}: ", "Options");

procfs/src/crypto.rs

@@ -1,6 +1,5 @@
-
-use procfs_core::ProcResult;
 pub use procfs_core::CryptoTable;
+use procfs_core::ProcResult;
 
 use crate::Current;
 
@@ -12,7 +11,6 @@ pub fn crypto() -> ProcResult<CryptoTable> {
     CryptoTable::current()
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -23,4 +21,4 @@ mod tests {
         let table = table.expect("CrytoTable should have been read");
         assert!(!table.crypto_blocks.is_empty(), "Crypto table was empty");
     }
-}
+}

procfs/src/sys/kernel/mod.rs

@@ -66,7 +66,7 @@ impl Version {
         Self {
             major,
             minor,
-            patch: u16::from_ne_bytes([lo, hi])
+            patch: u16::from_ne_bytes([lo, hi]),
         }
     }
 

procfs/src/sys/kernel/random.rs

@@ -5,7 +5,7 @@
 use crate::{read_value, write_value, ProcError, ProcResult};
 use std::path::Path;
 
-const RANDOM_ROOT: &str = "/proc/sys/kernel/random"; 
+const RANDOM_ROOT: &str = "/proc/sys/kernel/random";
 
 /// This read-only file gives the available entropy, in bits. This will be a number in the range
 /// 0 to 4096