Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base * Second run * Add CI check * Fix compilation * More unnecessary braces * Handle weights * Use --all * Use correct attributes... * Fix UI tests * AHHHHHHHHH * 🤦 * Docs * Fix compilation * 🤷 * Please stop * 🤦 x 2 * More * make rustfmt.toml consistent with polkadot Co-authored-by: André Silva <andrerfosilva@gmail.com>
2026-04-27 15:07:59 +00:00 · 2021-07-21 16:32:32 +02:00
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
@@ -27,33 +27,27 @@
 pub mod cli;
 pub mod command;

-use std::{
-	fmt,
-	fmt::Debug,
-	marker::PhantomData,
-	str::FromStr,
-};
-use codec::{Encode, Decode};
+use codec::{Decode, Encode};
 use sc_client_api::BlockBackend;
 use sp_blockchain::HeaderBackend;
 use sp_core::hexdisplay::HexDisplay;
 use sp_runtime::{
 	generic::BlockId,
-	traits::{Block, HashFor, NumberFor, Hash}
+	traits::{Block, Hash, HashFor, NumberFor},
 };
+use std::{fmt, fmt::Debug, marker::PhantomData, str::FromStr};

 /// A helper type for a generic block input.
-pub type BlockAddressFor<TBlock> = BlockAddress<
-	<HashFor<TBlock> as Hash>::Output,
-	NumberFor<TBlock>
->;
+pub type BlockAddressFor<TBlock> =
+	BlockAddress<<HashFor<TBlock> as Hash>::Output, NumberFor<TBlock>>;

 /// A Pretty formatter implementation.
 pub trait PrettyPrinter<TBlock: Block> {
 	/// Nicely format block.
 	fn fmt_block(&self, fmt: &mut fmt::Formatter, block: &TBlock) -> fmt::Result;
 	/// Nicely format extrinsic.
-	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic) -> fmt::Result;
+	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic)
+		-> fmt::Result;
 }

 /// Default dummy debug printer.
@@ -72,7 +66,11 @@ impl<TBlock: Block> PrettyPrinter<TBlock> for DebugPrinter {
 		Ok(())
 	}

-	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic) -> fmt::Result {
+	fn fmt_extrinsic(
+		&self,
+		fmt: &mut fmt::Formatter,
+		extrinsic: &TBlock::Extrinsic,
+	) -> fmt::Result {
 		writeln!(fmt, " {:#?}", extrinsic)?;
 		writeln!(fmt, " Bytes: {:?}", HexDisplay::from(&extrinsic.encode()))?;
 		Ok(())
@@ -101,15 +99,14 @@ impl std::error::Error for Error {
 }

 /// A helper trait to access block headers and bodies.
-pub trait ChainAccess<TBlock: Block>:
-	HeaderBackend<TBlock> +
-	BlockBackend<TBlock>
-{}
+pub trait ChainAccess<TBlock: Block>: HeaderBackend<TBlock> + BlockBackend<TBlock> {}

-impl<T, TBlock> ChainAccess<TBlock> for T where
+impl<T, TBlock> ChainAccess<TBlock> for T
+where
 	TBlock: Block,
 	T: sp_blockchain::HeaderBackend<TBlock> + sc_client_api::BlockBackend<TBlock>,
-{}
+{
+}

 /// Blockchain inspector.
 pub struct Inspector<TBlock: Block, TPrinter: PrettyPrinter<TBlock> = DebugPrinter> {
@@ -120,22 +117,16 @@ pub struct Inspector<TBlock: Block, TPrinter: PrettyPrinter<TBlock> = DebugPrint

 impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter> {
 	/// Create new instance of the inspector with default printer.
-	pub fn new(
-		chain: impl ChainAccess<TBlock> + 'static,
-	) -> Self where TPrinter: Default {
+	pub fn new(chain: impl ChainAccess<TBlock> + 'static) -> Self
+	where
+		TPrinter: Default,
+	{
 		Self::with_printer(chain, Default::default())
 	}

 	/// Customize pretty-printing of the data.
-	pub fn with_printer(
-		chain: impl ChainAccess<TBlock> + 'static,
-		printer: TPrinter,
-	) -> Self {
-		Inspector {
-			chain: Box::new(chain) as _,
-			printer,
-			_block: Default::default(),
-		}
+	pub fn with_printer(chain: impl ChainAccess<TBlock> + 'static, printer: TPrinter) -> Self {
+		Inspector { chain: Box::new(chain) as _, printer, _block: Default::default() }
 	}

 	/// Get a pretty-printed block.
@@ -153,25 +144,27 @@ impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter>

 	fn get_block(&self, input: BlockAddressFor<TBlock>) -> Result<TBlock, Error> {
 		Ok(match input {
-			BlockAddress::Bytes(bytes) => {
-				TBlock::decode(&mut &*bytes)?
-			},
+			BlockAddress::Bytes(bytes) => TBlock::decode(&mut &*bytes)?,
 			BlockAddress::Number(number) => {
 				let id = BlockId::number(number);
 				let not_found = format!("Could not find block {:?}", id);
-				let body = self.chain.block_body(&id)?
-					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
-				let header = self.chain.header(id)?
+				let body = self
+					.chain
+					.block_body(&id)?
 					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				let header =
+					self.chain.header(id)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
 				TBlock::new(header, body)
 			},
 			BlockAddress::Hash(hash) => {
 				let id = BlockId::hash(hash);
 				let not_found = format!("Could not find block {:?}", id);
-				let body = self.chain.block_body(&id)?
-					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
-				let header = self.chain.header(id)?
+				let body = self
+					.chain
+					.block_body(&id)?
 					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				let header =
+					self.chain.header(id)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
 				TBlock::new(header, body)
 			},
 		})
@@ -192,16 +185,14 @@ impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter>
 		let ext = match input {
 			ExtrinsicAddress::Block(block, index) => {
 				let block = self.get_block(block)?;
-				block.extrinsics()
-					.get(index)
-					.cloned()
-					.ok_or_else(|| Error::NotFound(format!(
-						"Could not find extrinsic {} in block {:?}", index, block
-					)))?
+				block.extrinsics().get(index).cloned().ok_or_else(|| {
+					Error::NotFound(format!(
+						"Could not find extrinsic {} in block {:?}",
+						index, block
+					))
+				})?
 			},
-			ExtrinsicAddress::Bytes(bytes) => {
-				TBlock::Extrinsic::decode(&mut &*bytes)?
-			}
+			ExtrinsicAddress::Bytes(bytes) => TBlock::Extrinsic::decode(&mut &*bytes)?,
 		};

 		Ok(format!("{}", ExtrinsicPrinter(ext, &self.printer)))
@@ -234,12 +225,12 @@ impl<Hash: FromStr, Number: FromStr> FromStr for BlockAddress<Hash, Number> {
 		}

 		// then assume it's bytes (hex-encoded)
-		sp_core::bytes::from_hex(s)
-			.map(Self::Bytes)
-			.map_err(|e| format!(
+		sp_core::bytes::from_hex(s).map(Self::Bytes).map_err(|e| {
+			format!(
 				"Given string does not look like hash or number. It could not be parsed as bytes either: {}",
 				e
-			))
+			)
+		})
 	}
 }

@@ -263,11 +254,13 @@ impl<Hash: FromStr + Debug, Number: FromStr + Debug> FromStr for ExtrinsicAddres

 		// split by a bunch of different characters
 		let mut it = s.split(|c| c == '.' || c == ':' || c == ' ');
-		let block = it.next()
+		let block = it
+			.next()
 			.expect("First element of split iterator is never empty; qed")
 			.parse()?;

-		let index = it.next()
+		let index = it
+			.next()
 			.ok_or_else(|| format!("Extrinsic index missing: example \"5:0\""))?
 			.parse()
 			.map_err(|e| format!("Invalid index format: {}", e))?;
@@ -290,10 +283,10 @@ mod tests {
 		let b2 = BlockAddress::from_str("0");
 		let b3 = BlockAddress::from_str("0x0012345f");

-
-		assert_eq!(b0, Ok(BlockAddress::Hash(
-			"3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()
-		)));
+		assert_eq!(
+			b0,
+			Ok(BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()))
+		);
 		assert_eq!(b1, Ok(BlockAddress::Number(1234)));
 		assert_eq!(b2, Ok(BlockAddress::Number(0)));
 		assert_eq!(b3, Ok(BlockAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
@@ -310,20 +303,16 @@ mod tests {
 		let b2 = ExtrinsicAddress::from_str("0 0");
 		let b3 = ExtrinsicAddress::from_str("0x0012345f");

-
 		assert_eq!(e0, Err("Extrinsic index missing: example \"5:0\"".into()));
-		assert_eq!(b0, Ok(ExtrinsicAddress::Block(
-			BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()),
-			5
-		)));
-		assert_eq!(b1, Ok(ExtrinsicAddress::Block(
-			BlockAddress::Number(1234),
-			0
-		)));
-		assert_eq!(b2, Ok(ExtrinsicAddress::Block(
-			BlockAddress::Number(0),
-			0
-		)));
+		assert_eq!(
+			b0,
+			Ok(ExtrinsicAddress::Block(
+				BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()),
+				5
+			))
+		);
+		assert_eq!(b1, Ok(ExtrinsicAddress::Block(BlockAddress::Number(1234), 0)));
+		assert_eq!(b2, Ok(ExtrinsicAddress::Block(BlockAddress::Number(0), 0)));
 		assert_eq!(b3, Ok(ExtrinsicAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
 	}
 }