chore: Format imports using rustfmt (#2812)

## Description

This enables a strict style in rustfmt to format imports statements. It
needs rust nightly for rustfmt to be able to do this.

To not make the `cargo fmt` from stable rust really noisy it does not
add a rustfmt.toml file, instead it adds a `cargo-make` task to automate
running this locally. This same task is used in CI to run the formatter.

The `Crate`m formatting will be preserved by the default configuration
of rust-analyzer, which makes external contributions easier as well,
most folks shouldn't be running into this formatter.

## Breaking Changes

<!-- Optional, if there are any breaking changes document them,
including how to migrate older code. -->

## Notes & open questions

I guess we need buy-in from everyone on the team for this.

## Change checklist

- [x] Self-review.
- [x] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [x] Tests if relevant.
- [x] All breaking changes documented.

---------

Co-authored-by: Diva M <divma@protonmail.com>
Co-authored-by: Divma <26765164+divagant-martian@users.noreply.github.com>

Author: flub

Makefile.toml

@@ -0,0 +1,28 @@
+# Use cargo-make to run tasks here: https://crates.io/crates/cargo-make
+
+[tasks.format]
+workspace = false
+command = "cargo"
+args = [
+     "fmt",
+     "--all",
+     "--",
+     "--config",
+     "unstable_features=true",
+     "--config",
+     "imports_granularity=Crate,group_imports=StdExternalCrate,reorder_imports=true",
+]
+
+[tasks.format-check]
+workspace = false
+command = "cargo"
+args = [
+     "fmt",
+     "--all",
+     "--check",
+     "--",
+     "--config",
+     "unstable_features=true",
+     "--config",
+     "imports_granularity=Crate,group_imports=StdExternalCrate,reorder_imports=true",
+]

iroh-blobs/examples/connect/mod.rs

@@ -1,7 +1,8 @@
 //! Common code used to created quinn connections in the examples
+use std::{path::PathBuf, sync::Arc};
+
 use anyhow::{bail, Context, Result};
 use quinn::crypto::rustls::{QuicClientConfig, QuicServerConfig};
-use std::{path::PathBuf, sync::Arc};
 use tokio::fs;
 
 pub const EXAMPLE_ALPN: &[u8] = b"n0/iroh/examples/bytes/0";

iroh-blobs/examples/fetch-fsm.rs

@@ -6,15 +6,14 @@
 use std::net::SocketAddr;
 
 use anyhow::{Context, Result};
-use iroh_io::ConcatenateSliceWriter;
-use tracing_subscriber::{prelude::*, EnvFilter};
-
 use iroh_blobs::{
     get::fsm::{AtInitial, ConnectedNext, EndBlobNext},
     hashseq::HashSeq,
     protocol::GetRequest,
     Hash,
 };
+use iroh_io::ConcatenateSliceWriter;
+use tracing_subscriber::{prelude::*, EnvFilter};
 
 mod connect;
 use connect::{load_certs, make_client_endpoint};

iroh-blobs/examples/fetch-stream.rs

@@ -3,26 +3,21 @@
 //! Since this example does not use [`iroh-net::Endpoint`], it does not do any holepunching, and so will only work locally or between two processes that have public IP addresses.
 //!
 //! Run the provide-bytes example first. It will give instructions on how to run this example properly.
-use std::net::SocketAddr;
+use std::{io, net::SocketAddr};
 
 use anyhow::{Context, Result};
-use tracing_subscriber::{prelude::*, EnvFilter};
-
-use std::io;
-
 use bao_tree::io::fsm::BaoContentItem;
 use bytes::Bytes;
 use futures_lite::{Stream, StreamExt};
-use genawaiter::sync::Co;
-use genawaiter::sync::Gen;
-use tokio::io::AsyncWriteExt;
-
+use genawaiter::sync::{Co, Gen};
 use iroh_blobs::{
     get::fsm::{AtInitial, BlobContentNext, ConnectedNext, EndBlobNext},
     hashseq::HashSeq,
     protocol::GetRequest,
     Hash,
 };
+use tokio::io::AsyncWriteExt;
+use tracing_subscriber::{prelude::*, EnvFilter};
 
 mod connect;
 use connect::{load_certs, make_client_endpoint};

iroh-blobs/examples/provide-bytes.rs

@@ -10,11 +10,10 @@
 //!    cargo run --example provide-bytes collection
 //! To provide a collection (multiple blobs)
 use anyhow::Result;
+use iroh_blobs::{format::collection::Collection, util::local_pool::LocalPool, Hash};
 use tracing::warn;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
-use iroh_blobs::{format::collection::Collection, util::local_pool::LocalPool, Hash};
-
 mod connect;
 use connect::{make_and_write_certs, make_server_endpoint, CERT_PATH};
 

iroh-blobs/src/downloader/get.rs

@@ -2,14 +2,14 @@
 //!
 //! [`Connection`]: iroh_net::endpoint::Connection
 
-use crate::{
-    get::{db::get_to_db_in_steps, error::GetError},
-    store::Store,
-};
 use futures_lite::FutureExt;
 use iroh_net::endpoint;
 
 use super::{progress::BroadcastProgressSender, DownloadKind, FailureAction, GetStartFut, Getter};
+use crate::{
+    get::{db::get_to_db_in_steps, error::GetError},
+    store::Store,
+};
 
 impl From<GetError> for FailureAction {
     fn from(e: GetError) -> Self {
@@ -74,8 +74,9 @@ impl super::NeedsConn<endpoint::Connection> for crate::get::db::GetStateNeedsCon
 
 #[cfg(feature = "metrics")]
 fn track_metrics(res: &Result<crate::get::Stats, GetError>) {
-    use crate::metrics::Metrics;
     use iroh_metrics::{inc, inc_by};
+
+    use crate::metrics::Metrics;
     match res {
         Ok(stats) => {
             let crate::get::Stats {

iroh-blobs/src/downloader/progress.rs

@@ -9,13 +9,12 @@ use std::{
 use anyhow::anyhow;
 use parking_lot::Mutex;
 
+use super::DownloadKind;
 use crate::{
     get::{db::DownloadProgress, progress::TransferState},
     util::progress::{AsyncChannelProgressSender, IdGenerator, ProgressSendError, ProgressSender},
 };
 
-use super::DownloadKind;
-
 /// The channel that can be used to subscribe to progress updates.
 pub type ProgressSubscriber = AsyncChannelProgressSender<DownloadProgress>;
 

iroh-blobs/src/downloader/test.rs

@@ -1,13 +1,14 @@
 #![cfg(test)]
-use anyhow::anyhow;
 use std::{
     sync::atomic::AtomicUsize,
     time::{Duration, Instant},
 };
 
+use anyhow::anyhow;
 use futures_util::future::FutureExt;
 use iroh_net::key::SecretKey;
 
+use super::*;
 use crate::{
     get::{
         db::BlobId,
@@ -19,8 +20,6 @@ use crate::{
     },
 };
 
-use super::*;
-
 mod dialer;
 mod getter;
 

iroh-blobs/src/downloader/test/getter.rs

@@ -3,9 +3,8 @@
 use futures_lite::{future::Boxed as BoxFuture, FutureExt};
 use parking_lot::RwLock;
 
-use crate::downloader;
-
 use super::*;
+use crate::downloader;
 
 #[derive(Default, Clone, derive_more::Debug)]
 #[debug("TestingGetter")]

iroh-blobs/src/get.rs

@@ -12,21 +12,23 @@
 //! or you can choose to finish early.
 //!
 //! [iroh-net]: https://docs.rs/iroh-net
-use std::error::Error;
-use std::fmt::{self, Debug};
-use std::time::{Duration, Instant};
+use std::{
+    error::Error,
+    fmt::{self, Debug},
+    time::{Duration, Instant},
+};
 
-use crate::Hash;
 use anyhow::Result;
-use bao_tree::io::fsm::BaoContentItem;
-use bao_tree::ChunkNum;
+use bao_tree::{io::fsm::BaoContentItem, ChunkNum};
 use iroh_net::endpoint::{self, RecvStream, SendStream};
 use serde::{Deserialize, Serialize};
 use tracing::{debug, error};
 
-use crate::protocol::RangeSpecSeq;
-use crate::util::io::{TrackingReader, TrackingWriter};
-use crate::IROH_BLOCK_SIZE;
+use crate::{
+    protocol::RangeSpecSeq,
+    util::io::{TrackingReader, TrackingWriter},
+    Hash, IROH_BLOCK_SIZE,
+};
 
 pub mod db;
 pub mod error;
@@ -59,13 +61,6 @@ impl Stats {
 pub mod fsm {
     use std::{io, result};
 
-    use crate::{
-        protocol::{GetRequest, NonEmptyRequestRangeSpecIter, Request, MAX_MESSAGE_SIZE},
-        store::BaoBatchWriter,
-    };
-
-    use super::*;
-
     use bao_tree::{
         io::fsm::{OutboardMut, ResponseDecoder, ResponseDecoderNext},
         BaoTree, ChunkRanges, TreeNode,
@@ -75,6 +70,12 @@ pub mod fsm {
     use iroh_net::endpoint::Connection;
     use tokio::io::AsyncWriteExt;
 
+    use super::*;
+    use crate::{
+        protocol::{GetRequest, NonEmptyRequestRangeSpecIter, Request, MAX_MESSAGE_SIZE},
+        store::BaoBatchWriter,
+    };
+
     type WrappedRecvStream = TrackingReader<TokioStreamReader<RecvStream>>;
 
     self_cell::self_cell! {

iroh-blobs/src/get/db.rs

@@ -1,26 +1,20 @@
 //! Functions that use the iroh-blobs protocol in conjunction with a bao store.
 
-use std::future::Future;
-use std::io;
-use std::num::NonZeroU64;
-use std::pin::Pin;
+use std::{future::Future, io, num::NonZeroU64, pin::Pin};
 
+use anyhow::anyhow;
+use bao_tree::{ChunkNum, ChunkRanges};
 use futures_lite::StreamExt;
 use genawaiter::{
     rc::{Co, Gen},
     GeneratorState,
 };
-use iroh_base::hash::Hash;
-use iroh_base::rpc::RpcError;
+use iroh_base::{hash::Hash, rpc::RpcError};
+use iroh_io::AsyncSliceReader;
 use iroh_net::endpoint::Connection;
 use serde::{Deserialize, Serialize};
 use tokio::sync::oneshot;
-
-use crate::hashseq::parse_hash_seq;
-use crate::protocol::RangeSpec;
-use crate::store::BaoBatchWriter;
-use crate::store::BaoBlobSize;
-use crate::store::FallibleProgressBatchWriter;
+use tracing::trace;
 
 use crate::{
     get::{
@@ -30,15 +24,15 @@ use crate::{
         progress::TransferState,
         Stats,
     },
-    protocol::{GetRequest, RangeSpecSeq},
-    store::{MapEntry, MapEntryMut, MapMut, Store as BaoStore},
+    hashseq::parse_hash_seq,
+    protocol::{GetRequest, RangeSpec, RangeSpecSeq},
+    store::{
+        BaoBatchWriter, BaoBlobSize, FallibleProgressBatchWriter, MapEntry, MapEntryMut, MapMut,
+        Store as BaoStore,
+    },
     util::progress::{IdGenerator, ProgressSender},
     BlobFormat, HashAndFormat,
 };
-use anyhow::anyhow;
-use bao_tree::{ChunkNum, ChunkRanges};
-use iroh_io::AsyncSliceReader;
-use tracing::trace;
 
 type GetGenerator = Gen<Yield, (), Pin<Box<dyn Future<Output = Result<Stats, GetError>>>>>;
 type GetFuture = Pin<Box<dyn Future<Output = Result<Stats, GetError>> + 'static>>;

iroh-blobs/src/get/progress.rs

@@ -5,9 +5,8 @@ use std::{collections::HashMap, num::NonZeroU64};
 use serde::{Deserialize, Serialize};
 use tracing::warn;
 
-use crate::{protocol::RangeSpec, store::BaoBlobSize, Hash};
-
 use super::db::{BlobId, DownloadProgress};
+use crate::{protocol::RangeSpec, store::BaoBlobSize, Hash};
 
 /// The identifier for progress events.
 pub type ProgressId = u64;

iroh-blobs/src/get/request.rs

@@ -1,17 +1,17 @@
 //! Utilities for complex get requests.
 use std::sync::Arc;
 
-use crate::{
-    hashseq::HashSeq,
-    protocol::{GetRequest, RangeSpecSeq},
-    Hash, HashAndFormat,
-};
 use bao_tree::{ChunkNum, ChunkRanges};
 use bytes::Bytes;
 use iroh_net::endpoint::Connection;
 use rand::Rng;
 
 use super::{fsm, Stats};
+use crate::{
+    hashseq::HashSeq,
+    protocol::{GetRequest, RangeSpecSeq},
+    Hash, HashAndFormat,
+};
 
 /// Get the claimed size of a blob from a peer.
 ///

iroh-blobs/src/hashseq.rs

@@ -1,8 +1,10 @@
 //! traits related to collections of blobs
-use crate::Hash;
+use std::{fmt::Debug, io};
+
 use bytes::Bytes;
 use iroh_io::{AsyncSliceReader, AsyncSliceReaderExt};
-use std::{fmt::Debug, io};
+
+use crate::Hash;
 
 /// A sequence of links, backed by a [`Bytes`] object.
 #[derive(Debug, Clone, derive_more::Into)]

iroh-blobs/src/lib.rs

@@ -40,10 +40,10 @@ pub mod provider;
 pub mod store;
 pub mod util;
 
-pub use crate::util::{Tag, TempTag};
+use bao_tree::BlockSize;
 pub use iroh_base::hash::{BlobFormat, Hash, HashAndFormat};
 
-use bao_tree::BlockSize;
+pub use crate::util::{Tag, TempTag};
 
 /// Block size used by iroh, 2^4*1024 = 16KiB
 pub const IROH_BLOCK_SIZE: BlockSize = BlockSize::from_chunk_log(4);

iroh-blobs/src/protocol/range_spec.rs

@@ -354,10 +354,11 @@ impl<'a> Iterator for NonEmptyRequestRangeSpecIter<'a> {
 mod tests {
     use std::ops::Range;
 
-    use super::*;
     use iroh_test::{assert_eq_hex, hexdump::parse_hexdump};
     use proptest::prelude::*;
 
+    use super::*;
+
     fn ranges(value_range: Range<u64>) -> impl Strategy<Value = ChunkRanges> {
         prop::collection::vec((value_range.clone(), value_range), 0..16).prop_map(|v| {
             let mut res = ChunkRanges::empty();