Bring rustfmt.toml in sync with polkadot-sdk (#71)

Make `rustfmt.toml` identical to the polkadot-sdk's one.

Personally, I don't like some choices like `binop_separator = "Back"`,
`match_arm_leading_pipes = "Preserve"`, and `hard_tabs = true`, but I
don't think it makes sense having different code style settings in
polkadot-sdk & litep2p.

build.rs

@@ -1,14 +1,14 @@
 fn main() {
-    prost_build::compile_protos(
-        &[
-            "src/schema/keys.proto",
-            "src/schema/noise.proto",
-            "src/schema/webrtc.proto",
-            "src/protocol/libp2p/schema/identify.proto",
-            "src/protocol/libp2p/schema/kademlia.proto",
-            "src/protocol/libp2p/schema/bitswap.proto",
-        ],
-        &["src"],
-    )
-    .unwrap();
+	prost_build::compile_protos(
+		&[
+			"src/schema/keys.proto",
+			"src/schema/noise.proto",
+			"src/schema/webrtc.proto",
+			"src/protocol/libp2p/schema/identify.proto",
+			"src/protocol/libp2p/schema/kademlia.proto",
+			"src/protocol/libp2p/schema/bitswap.proto",
+		],
+		&["src"],
+	)
+	.unwrap();
 }

examples/custom_executor.rs

@@ -28,11 +28,11 @@
 //! Run: `RUST_LOG=info cargo run --example custom_executor`
 
 use litep2p::{
-    config::ConfigBuilder,
-    executor::Executor,
-    protocol::libp2p::ping::{Config as PingConfig, PingEvent},
-    transport::tcp::config::Config as TcpConfig,
-    Litep2p,
+	config::ConfigBuilder,
+	executor::Executor,
+	protocol::libp2p::ping::{Config as PingConfig, PingEvent},
+	transport::tcp::config::Config as TcpConfig,
+	Litep2p,
 };
 
 use futures::{future::BoxFuture, stream::FuturesUnordered, Stream, StreamExt};
@@ -44,112 +44,102 @@ use std::{future::Future, pin::Pin, sync::Arc};
 ///
 /// Just a wrapper around `FuturesUnordered` which receives the futures over `mpsc::Receiver`.
 struct TaskExecutor {
-    rx: Receiver<Pin<Box<dyn Future<Output = ()> + Send>>>,
-    futures: FuturesUnordered<BoxFuture<'static, ()>>,
+	rx: Receiver<Pin<Box<dyn Future<Output = ()> + Send>>>,
+	futures: FuturesUnordered<BoxFuture<'static, ()>>,
 }
 
 impl TaskExecutor {
-    /// Create new [`TaskExecutor`].
-    fn new() -> (Self, Sender<Pin<Box<dyn Future<Output = ()> + Send>>>) {
-        let (tx, rx) = channel(64);
-
-        (
-            Self {
-                rx,
-                futures: FuturesUnordered::new(),
-            },
-            tx,
-        )
-    }
-
-    /// Drive the futures forward and poll the receiver for any new futures.
-    async fn next(&mut self) {
-        loop {
-            tokio::select! {
-                future = self.rx.recv() => self.futures.push(future.unwrap()),
-                _ = self.futures.next(), if !self.futures.is_empty() => {}
-            }
-        }
-    }
+	/// Create new [`TaskExecutor`].
+	fn new() -> (Self, Sender<Pin<Box<dyn Future<Output = ()> + Send>>>) {
+		let (tx, rx) = channel(64);
+
+		(Self { rx, futures: FuturesUnordered::new() }, tx)
+	}
+
+	/// Drive the futures forward and poll the receiver for any new futures.
+	async fn next(&mut self) {
+		loop {
+			tokio::select! {
+				future = self.rx.recv() => self.futures.push(future.unwrap()),
+				_ = self.futures.next(), if !self.futures.is_empty() => {}
+			}
+		}
+	}
 }
 
 struct TaskExecutorHandle {
-    tx: Sender<Pin<Box<dyn Future<Output = ()> + Send>>>,
+	tx: Sender<Pin<Box<dyn Future<Output = ()> + Send>>>,
 }
 
 impl Executor for TaskExecutorHandle {
-    fn run(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
-        let _ = self.tx.try_send(future);
-    }
+	fn run(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
+		let _ = self.tx.try_send(future);
+	}
 
-    fn run_with_name(&self, _: &'static str, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
-        let _ = self.tx.try_send(future);
-    }
+	fn run_with_name(&self, _: &'static str, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
+		let _ = self.tx.try_send(future);
+	}
 }
 
-fn make_litep2p() -> (
-    Litep2p,
-    TaskExecutor,
-    Box<dyn Stream<Item = PingEvent> + Send + Unpin>,
-) {
-    let (executor, sender) = TaskExecutor::new();
-    let (ping_config, ping_event_stream) = PingConfig::default();
-
-    let litep2p = Litep2p::new(
-        ConfigBuilder::new()
-            .with_executor(Arc::new(TaskExecutorHandle { tx: sender.clone() }))
-            .with_tcp(TcpConfig {
-                listen_addresses: vec!["/ip6/::1/tcp/0".parse().unwrap()],
-                ..Default::default()
-            })
-            .with_libp2p_ping(ping_config)
-            .build(),
-    )
-    .unwrap();
-
-    (litep2p, executor, ping_event_stream)
+fn make_litep2p() -> (Litep2p, TaskExecutor, Box<dyn Stream<Item = PingEvent> + Send + Unpin>) {
+	let (executor, sender) = TaskExecutor::new();
+	let (ping_config, ping_event_stream) = PingConfig::default();
+
+	let litep2p = Litep2p::new(
+		ConfigBuilder::new()
+			.with_executor(Arc::new(TaskExecutorHandle { tx: sender.clone() }))
+			.with_tcp(TcpConfig {
+				listen_addresses: vec!["/ip6/::1/tcp/0".parse().unwrap()],
+				..Default::default()
+			})
+			.with_libp2p_ping(ping_config)
+			.build(),
+	)
+	.unwrap();
+
+	(litep2p, executor, ping_event_stream)
 }
 
 #[tokio::main]
 async fn main() {
-    let _ = tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .try_init();
-
-    // create two identical litep2ps
-    let (mut litep2p1, mut executor1, mut ping_event_stream1) = make_litep2p();
-    let (mut litep2p2, mut executor2, mut ping_event_stream2) = make_litep2p();
-
-    // dial `litep2p1`
-    litep2p2
-        .dial_address(litep2p1.listen_addresses().next().unwrap().clone())
-        .await
-        .unwrap();
-
-    tokio::spawn(async move {
-        loop {
-            tokio::select! {
-                _ = executor1.next() => {}
-                _ = litep2p1.next_event() => {},
-                _ = ping_event_stream1.next() => {},
-            }
-        }
-    });
-
-    // poll litep2p, task executor and ping event stream all together
-    //
-    // since a custom task executor was provided, it's now the user's responsibility
-    // to actually make sure to poll those futures so that litep2p can make progress
-    loop {
-        tokio::select! {
-            _ = executor2.next() => {}
-            _ = litep2p2.next_event() => {},
-            event = ping_event_stream2.next() => match event {
-                Some(PingEvent::Ping { peer, ping }) => tracing::info!(
-                    "ping time with {peer:?}: {ping:?}"
-                ),
-                _ => {}
-            }
-        }
-    }
+	let _ = tracing_subscriber::fmt()
+		.with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+		.try_init();
+
+	// create two identical litep2ps
+	let (mut litep2p1, mut executor1, mut ping_event_stream1) = make_litep2p();
+	let (mut litep2p2, mut executor2, mut ping_event_stream2) = make_litep2p();
+
+	// dial `litep2p1`
+	litep2p2
+		.dial_address(litep2p1.listen_addresses().next().unwrap().clone())
+		.await
+		.unwrap();
+
+	tokio::spawn(async move {
+		loop {
+			tokio::select! {
+				_ = executor1.next() => {}
+				_ = litep2p1.next_event() => {},
+				_ = ping_event_stream1.next() => {},
+			}
+		}
+	});
+
+	// poll litep2p, task executor and ping event stream all together
+	//
+	// since a custom task executor was provided, it's now the user's responsibility
+	// to actually make sure to poll those futures so that litep2p can make progress
+	loop {
+		tokio::select! {
+			_ = executor2.next() => {}
+			_ = litep2p2.next_event() => {},
+			event = ping_event_stream2.next() => match event {
+				Some(PingEvent::Ping { peer, ping }) => tracing::info!(
+					"ping time with {peer:?}: {ping:?}"
+				),
+				_ => {}
+			}
+		}
+	}
 }