chore: Organize imports automatically

`Makefile`:
- `imports_granularity` is set to `Crate` because I find it the option
  that most helps me to see how imports relate to each other and it
  results in the most concise imports.
  One drawback is that it tends to lead to more merge conflicts,
  but on this project merges and rebases are rare so this shouldn't be
  a problem in practice.

Author: apljungquist

Makefile

@@ -175,7 +175,10 @@ check_docs:
 
 ## Check that the code is formatted correctly
 check_format:
-	cargo fmt --check
+	cargo fmt \
+		--check \
+		-- \
+		--config imports_granularity=Crate,group_imports=StdExternalCrate
 .PHONY: check_format
 
 ## Check that generated files are up to date
@@ -241,7 +244,9 @@ check_tests:
 
 ## Attempt to fix formatting automatically
 fix_format:
-	cargo fmt
+	cargo fmt \
+		-- \
+		--config imports_granularity=Crate,group_imports=StdExternalCrate
 .PHONY: fix_format
 
 ## Attempt to fix lints automatically

apps/event_subscribe/src/main.rs

@@ -2,13 +2,14 @@
 //! An example of how to subscribe to manual trigger events using `axevent::nonblock`
 
 use anyhow::Context;
-use axevent::flex::{Handler, KeyValueSet};
-use axevent::nonblock::Subscription;
+use axevent::{
+    flex::{Handler, KeyValueSet},
+    nonblock::Subscription,
+};
+use futures_lite::StreamExt;
 use glib::MainContext;
 use log::{error, info};
 
-use futures_lite::StreamExt;
-
 async fn app() -> anyhow::Result<()> {
     let mut subscription_template = KeyValueSet::new();
     subscription_template

apps/subscribe_to_event/src/main.rs

@@ -3,8 +3,7 @@
 //! installed and running as it relies on those events to receive and log data.
 
 use axevent::flex::{Handler, KeyValueSet, Subscription};
-use log::error;
-use log::info;
+use log::{error, info};
 
 fn onviftrigger_subscription(handler: &Handler, token: u32) -> anyhow::Result<Subscription> {
     let mut key_value_set = KeyValueSet::new();

crates/axevent/src/nonblock.rs

@@ -5,11 +5,12 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::flex::{Event, Handler, KeyValueSet};
 use async_channel::Receiver;
 use futures_lite::Stream;
 use log::{error, warn};
 
+use crate::flex::{Event, Handler, KeyValueSet};
+
 /// Represents an event subscription that can be iterated asynchronously
 ///
 /// # Panics

crates/axstorage/src/flex.rs

@@ -1,3 +1,12 @@
+use std::{
+    ffi::{c_char, c_void, CStr, OsStr},
+    mem,
+    mem::ManuallyDrop,
+    path::Path,
+    ptr,
+    ptr::NonNull,
+};
+
 use axstorage_sys::{
     ax_storage_error_quark, ax_storage_get_path, ax_storage_get_status, ax_storage_get_storage_id,
     ax_storage_get_type, ax_storage_list, ax_storage_release_async, ax_storage_setup_async,
@@ -19,15 +28,6 @@ use glib::{
     GStringPtr, List, Quark,
 };
 use glib_sys::{g_free, g_strdup, gpointer, GTRUE};
-use std::ffi::OsStr;
-use std::path::Path;
-use std::{
-    ffi::{c_char, c_void, CStr},
-    mem,
-    mem::ManuallyDrop,
-    ptr,
-    ptr::NonNull,
-};
 // The documentation states that we are responsible for freeing the callbacks, but it does state
 // when it is safe to do so making it impossible to create a Rust abstraction that both:
 // - does not leak memory and

crates/ffi_patterns/src/sys.rs

@@ -1,5 +1,7 @@
-use std::collections::HashMap;
-use std::ffi::{c_int, c_void};
+use std::{
+    collections::HashMap,
+    ffi::{c_int, c_void},
+};
 
 type Callback = unsafe extern "C" fn(*mut c_void);
 

crates/ffi_patterns/src/tests.rs

@@ -1,10 +1,15 @@
+use std::{
+    collections::HashMap,
+    ffi::c_void,
+    marker::PhantomData,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Mutex,
+    },
+    thread::{spawn, JoinHandle},
+};
+
 use crate::sys;
-use std::collections::HashMap;
-use std::ffi::c_void;
-use std::marker::PhantomData;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Mutex;
-use std::thread::{spawn, JoinHandle};
 
 /// A struct that calls a function when dropped.
 /// This is intended to help make sure pointers are cleaned up at an appropriate time.

crates/mdb/src/error.rs

@@ -1,6 +1,8 @@
-use std::ffi::{c_char, CStr};
-use std::fmt::{Debug, Display, Formatter};
-use std::marker::PhantomData;
+use std::{
+    ffi::{c_char, CStr},
+    fmt::{Debug, Display, Formatter},
+    marker::PhantomData,
+};
 
 unsafe fn pchar_to_string(p_value: *const c_char) -> String {
     assert!(!p_value.is_null());