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>

substrate/primitives/core/src/offchain/mod.rs

@@ -17,10 +17,13 @@
 
 //! Offchain workers types
 
-use codec::{Encode, Decode};
-use sp_std::{prelude::{Vec, Box}, convert::TryFrom};
 use crate::{OpaquePeerId, RuntimeDebug};
-use sp_runtime_interface::pass_by::{PassByCodec, PassByInner, PassByEnum};
+use codec::{Decode, Encode};
+use sp_runtime_interface::pass_by::{PassByCodec, PassByEnum, PassByInner};
+use sp_std::{
+	convert::TryFrom,
+	prelude::{Box, Vec},
+};
 
 pub use crate::crypto::KeyTypeId;
 
@@ -30,7 +33,7 @@ pub mod storage;
 pub mod testing;
 
 /// Persistent storage prefix used by the Offchain Worker API when creating a DB key.
-pub const STORAGE_PREFIX : &[u8] = b"storage";
+pub const STORAGE_PREFIX: &[u8] = b"storage";
 
 /// Offchain DB persistent (non-fork-aware) storage.
 pub trait OffchainStorage: Clone + Send + Sync {
@@ -93,7 +96,9 @@ impl From<StorageKind> for u32 {
 }
 
 /// Opaque type for offchain http requests.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, PassByInner)]
+#[derive(
+	Clone, Copy, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, PassByInner,
+)]
 #[cfg_attr(feature = "std", derive(Hash))]
 pub struct HttpRequestId(pub u16);
 
@@ -123,7 +128,7 @@ impl TryFrom<u32> for HttpError {
 			e if e == HttpError::DeadlineReached as u8 as u32 => Ok(HttpError::DeadlineReached),
 			e if e == HttpError::IoError as u8 as u32 => Ok(HttpError::IoError),
 			e if e == HttpError::Invalid as u8 as u32 => Ok(HttpError::Invalid),
-			_ => Err(())
+			_ => Err(()),
 		}
 	}
 }
@@ -202,11 +207,15 @@ impl OpaqueMultiaddr {
 }
 
 /// Opaque timestamp type
-#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Default, RuntimeDebug, PassByInner, Encode, Decode)]
+#[derive(
+	Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Default, RuntimeDebug, PassByInner, Encode, Decode,
+)]
 pub struct Timestamp(u64);
 
 /// Duration type
-#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Default, RuntimeDebug, PassByInner, Encode, Decode)]
+#[derive(
+	Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Default, RuntimeDebug, PassByInner, Encode, Decode,
+)]
 pub struct Duration(u64);
 
 impl Duration {
@@ -290,11 +299,7 @@ impl Capabilities {
 	/// Those calls should be allowed to sign and submit transactions
 	/// and access offchain workers database (but read only!).
 	pub fn rich_offchain_call() -> Self {
-		[
-			Capability::TransactionPool,
-			Capability::Keystore,
-			Capability::OffchainDbRead,
-		][..].into()
+		[Capability::TransactionPool, Capability::Keystore, Capability::OffchainDbRead][..].into()
 	}
 
 	/// Check if particular capability is enabled.
@@ -345,12 +350,11 @@ pub trait Externalities: Send {
 	/// Returns an error if:
 	/// - No new request identifier could be allocated.
 	/// - The method or URI contain invalid characters.
-	///
 	fn http_request_start(
 		&mut self,
 		method: &str,
 		uri: &str,
-		meta: &[u8]
+		meta: &[u8],
 	) -> Result<HttpRequestId, ()>;
 
 	/// Append header to the request.
@@ -365,12 +369,11 @@ pub trait Externalities: Send {
 	///
 	/// An error doesn't poison the request, and you can continue as if the call had never been
 	/// made.
-	///
 	fn http_request_add_header(
 		&mut self,
 		request_id: HttpRequestId,
 		name: &str,
-		value: &str
+		value: &str,
 	) -> Result<(), ()>;
 
 	/// Write a chunk of request body.
@@ -387,12 +390,11 @@ pub trait Externalities: Send {
 	/// - The deadline is reached.
 	/// - An I/O error has happened, for example the remote has closed our
 	///   request. The request is then considered invalid.
-	///
 	fn http_request_write_body(
 		&mut self,
 		request_id: HttpRequestId,
 		chunk: &[u8],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Result<(), HttpError>;
 
 	/// Block and wait for the responses for given requests.
@@ -408,7 +410,7 @@ pub trait Externalities: Send {
 	fn http_response_wait(
 		&mut self,
 		ids: &[HttpRequestId],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Vec<HttpRequestStatus>;
 
 	/// Read all response headers.
@@ -420,10 +422,7 @@ pub trait Externalities: Send {
 	///
 	/// Returns an empty list if the identifier is unknown/invalid, hasn't
 	/// received a response, or has finished.
-	fn http_response_headers(
-		&mut self,
-		request_id: HttpRequestId
-	) -> Vec<(Vec<u8>, Vec<u8>)>;
+	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)>;
 
 	/// Read a chunk of body response to given buffer.
 	///
@@ -443,12 +442,11 @@ pub trait Externalities: Send {
 	/// - The deadline is reached.
 	/// - An I/O error has happened, for example the remote has closed our
 	///   request. The request is then considered invalid.
-	///
 	fn http_response_read_body(
 		&mut self,
 		request_id: HttpRequestId,
 		buffer: &mut [u8],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Result<usize, HttpError>;
 
 	/// Set the authorized nodes from runtime.
@@ -466,11 +464,11 @@ pub trait Externalities: Send {
 
 impl<T: Externalities + ?Sized> Externalities for Box<T> {
 	fn is_validator(&self) -> bool {
-		(& **self).is_validator()
+		(&**self).is_validator()
 	}
 
 	fn network_state(&self) -> Result<OpaqueNetworkState, ()> {
-		(& **self).network_state()
+		(&**self).network_state()
 	}
 
 	fn timestamp(&mut self) -> Timestamp {
@@ -485,11 +483,21 @@ impl<T: Externalities + ?Sized> Externalities for Box<T> {
 		(&mut **self).random_seed()
 	}
 
-	fn http_request_start(&mut self, method: &str, uri: &str, meta: &[u8]) -> Result<HttpRequestId, ()> {
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<HttpRequestId, ()> {
 		(&mut **self).http_request_start(method, uri, meta)
 	}
 
-	fn http_request_add_header(&mut self, request_id: HttpRequestId, name: &str, value: &str) -> Result<(), ()> {
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
 		(&mut **self).http_request_add_header(request_id, name, value)
 	}
 
@@ -497,12 +505,16 @@ impl<T: Externalities + ?Sized> Externalities for Box<T> {
 		&mut self,
 		request_id: HttpRequestId,
 		chunk: &[u8],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Result<(), HttpError> {
 		(&mut **self).http_request_write_body(request_id, chunk, deadline)
 	}
 
-	fn http_response_wait(&mut self, ids: &[HttpRequestId], deadline: Option<Timestamp>) -> Vec<HttpRequestStatus> {
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
 		(&mut **self).http_response_wait(ids, deadline)
 	}
 
@@ -514,7 +526,7 @@ impl<T: Externalities + ?Sized> Externalities for Box<T> {
 		&mut self,
 		request_id: HttpRequestId,
 		buffer: &mut [u8],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Result<usize, HttpError> {
 		(&mut **self).http_response_read_body(request_id, buffer, deadline)
 	}
@@ -533,10 +545,7 @@ pub struct LimitedExternalities<T> {
 impl<T> LimitedExternalities<T> {
 	/// Create new externalities limited to given `capabilities`.
 	pub fn new(capabilities: Capabilities, externalities: T) -> Self {
-		Self {
-			capabilities,
-			externalities,
-		}
+		Self { capabilities, externalities }
 	}
 
 	/// Check if given capability is allowed.
@@ -575,12 +584,22 @@ impl<T: Externalities> Externalities for LimitedExternalities<T> {
 		self.externalities.random_seed()
 	}
 
-	fn http_request_start(&mut self, method: &str, uri: &str, meta: &[u8]) -> Result<HttpRequestId, ()> {
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<HttpRequestId, ()> {
 		self.check(Capability::Http, "http_request_start");
 		self.externalities.http_request_start(method, uri, meta)
 	}
 
-	fn http_request_add_header(&mut self, request_id: HttpRequestId, name: &str, value: &str) -> Result<(), ()> {
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
 		self.check(Capability::Http, "http_request_add_header");
 		self.externalities.http_request_add_header(request_id, name, value)
 	}
@@ -589,13 +608,17 @@ impl<T: Externalities> Externalities for LimitedExternalities<T> {
 		&mut self,
 		request_id: HttpRequestId,
 		chunk: &[u8],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Result<(), HttpError> {
 		self.check(Capability::Http, "http_request_write_body");
 		self.externalities.http_request_write_body(request_id, chunk, deadline)
 	}
 
-	fn http_response_wait(&mut self, ids: &[HttpRequestId], deadline: Option<Timestamp>) -> Vec<HttpRequestStatus> {
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
 		self.check(Capability::Http, "http_response_wait");
 		self.externalities.http_response_wait(ids, deadline)
 	}
@@ -609,7 +632,7 @@ impl<T: Externalities> Externalities for LimitedExternalities<T> {
 		&mut self,
 		request_id: HttpRequestId,
 		buffer: &mut [u8],
-		deadline: Option<Timestamp>
+		deadline: Option<Timestamp>,
 	) -> Result<usize, HttpError> {
 		self.check(Capability::Http, "http_response_read_body");
 		self.externalities.http_response_read_body(request_id, buffer, deadline)
@@ -717,7 +740,8 @@ impl<T: DbExternalities> DbExternalities for LimitedExternalities<T> {
 		new_value: &[u8],
 	) -> bool {
 		self.check(Capability::OffchainDbWrite, "local_storage_compare_and_set");
-		self.externalities.local_storage_compare_and_set(kind, key, old_value, new_value)
+		self.externalities
+			.local_storage_compare_and_set(kind, key, old_value, new_value)
 	}
 
 	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {

substrate/primitives/core/src/offchain/storage.rs

@@ -17,9 +17,11 @@
 
 //! In-memory implementation of offchain workers database.
 
-use std::collections::hash_map::{HashMap, Entry};
 use crate::offchain::OffchainStorage;
-use std::iter::Iterator;
+use std::{
+	collections::hash_map::{Entry, HashMap},
+	iter::Iterator,
+};
 
 /// In-memory storage for offchain workers.
 #[derive(Debug, Clone, Default)]
@@ -29,12 +31,12 @@ pub struct InMemOffchainStorage {
 
 impl InMemOffchainStorage {
 	/// Consume the offchain storage and iterate over all key value pairs.
-	pub fn into_iter(self) -> impl Iterator<Item=(Vec<u8>,Vec<u8>)> {
+	pub fn into_iter(self) -> impl Iterator<Item = (Vec<u8>, Vec<u8>)> {
 		self.storage.into_iter()
 	}
 
 	/// Iterate over all key value pairs by reference.
-	pub fn iter(&self) -> impl Iterator<Item=(&Vec<u8>,&Vec<u8>)> {
+	pub fn iter(&self) -> impl Iterator<Item = (&Vec<u8>, &Vec<u8>)> {
 		self.storage.iter()
 	}
 
@@ -71,10 +73,13 @@ impl OffchainStorage for InMemOffchainStorage {
 		let key = prefix.iter().chain(key).cloned().collect();
 
 		match self.storage.entry(key) {
-			Entry::Vacant(entry) => if old_value.is_none() {
-				entry.insert(new_value.to_vec());
-				true
-			} else { false },
+			Entry::Vacant(entry) =>
+				if old_value.is_none() {
+					entry.insert(new_value.to_vec());
+					true
+				} else {
+					false
+				},
 			Entry::Occupied(ref mut entry) if Some(entry.get().as_slice()) == old_value => {
 				entry.insert(new_value.to_vec());
 				true

substrate/primitives/core/src/offchain/testing.rs

@@ -20,24 +20,18 @@
 //! Namely all ExecutionExtensions that allow mocking
 //! the extra APIs.
 
+use crate::{
+	offchain::{
+		self, storage::InMemOffchainStorage, HttpError, HttpRequestId as RequestId,
+		HttpRequestStatus as RequestStatus, OffchainOverlayedChange, OffchainStorage,
+		OpaqueNetworkState, StorageKind, Timestamp, TransactionPool,
+	},
+	OpaquePeerId,
+};
 use std::{
 	collections::{BTreeMap, VecDeque},
 	sync::Arc,
 };
-use crate::OpaquePeerId;
-use crate::offchain::{
-	self,
-	OffchainOverlayedChange,
-	storage::InMemOffchainStorage,
-	HttpError,
-	HttpRequestId as RequestId,
-	HttpRequestStatus as RequestStatus,
-	Timestamp,
-	StorageKind,
-	OpaqueNetworkState,
-	TransactionPool,
-	OffchainStorage,
-};
 
 use parking_lot::RwLock;
 
@@ -75,9 +69,7 @@ impl TestPersistentOffchainDB {
 
 	/// Create a new and empty offchain storage db for persistent items
 	pub fn new() -> Self {
-		Self {
-			persistent: Arc::new(RwLock::new(InMemOffchainStorage::default()))
-		}
+		Self { persistent: Arc::new(RwLock::new(InMemOffchainStorage::default())) }
 	}
 
 	/// Apply a set of off-chain changes directly to the test backend
@@ -88,7 +80,8 @@ impl TestPersistentOffchainDB {
 		let mut me = self.persistent.write();
 		for ((_prefix, key), value_operation) in changes {
 			match value_operation {
-				OffchainOverlayedChange::SetValue(val) => me.set(Self::PREFIX, key.as_slice(), val.as_slice()),
+				OffchainOverlayedChange::SetValue(val) =>
+					me.set(Self::PREFIX, key.as_slice(), val.as_slice()),
 				OffchainOverlayedChange::Remove => me.remove(Self::PREFIX, key.as_slice()),
 			}
 		}
@@ -124,7 +117,6 @@ impl OffchainStorage for TestPersistentOffchainDB {
 	}
 }
 
-
 /// Internal state of the externalities.
 ///
 /// This can be used in tests to respond or assert stuff about interactions.
@@ -151,20 +143,17 @@ impl OffchainState {
 		id: u16,
 		expected: PendingRequest,
 		response: impl Into<Vec<u8>>,
-		response_headers: impl IntoIterator<Item=(String, String)>,
+		response_headers: impl IntoIterator<Item = (String, String)>,
 	) {
 		match self.requests.get_mut(&RequestId(id)) {
 			None => {
 				panic!("Missing pending request: {:?}.\n\nAll: {:?}", id, self.requests);
-			}
+			},
 			Some(req) => {
-				assert_eq!(
-					*req,
-					expected,
-				);
+				assert_eq!(*req, expected,);
 				req.response = Some(response.into());
 				req.response_headers = response_headers.into_iter().collect();
-			}
+			},
 		}
 	}
 
@@ -213,7 +202,9 @@ impl TestOffchainExt {
 	}
 
 	/// Create new `TestOffchainExt` and a reference to the internal state.
-	pub fn with_offchain_db(offchain_db: TestPersistentOffchainDB) -> (Self, Arc<RwLock<OffchainState>>) {
+	pub fn with_offchain_db(
+		offchain_db: TestPersistentOffchainDB,
+	) -> (Self, Arc<RwLock<OffchainState>>) {
 		let (ext, state) = Self::new();
 		ext.0.write().persistent_storage = offchain_db;
 		(ext, state)
@@ -226,10 +217,7 @@ impl offchain::Externalities for TestOffchainExt {
 	}
 
 	fn network_state(&self) -> Result<OpaqueNetworkState, ()> {
-		Ok(OpaqueNetworkState {
-			peer_id: Default::default(),
-			external_addresses: vec![],
-		})
+		Ok(OpaqueNetworkState { peer_id: Default::default(), external_addresses: vec![] })
 	}
 
 	fn timestamp(&mut self) -> Timestamp {
@@ -244,15 +232,23 @@ impl offchain::Externalities for TestOffchainExt {
 		self.0.read().seed
 	}
 
-	fn http_request_start(&mut self, method: &str, uri: &str, meta: &[u8]) -> Result<RequestId, ()> {
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<RequestId, ()> {
 		let mut state = self.0.write();
 		let id = RequestId(state.requests.len() as u16);
-		state.requests.insert(id, PendingRequest {
-			method: method.into(),
-			uri: uri.into(),
-			meta: meta.into(),
-			..Default::default()
-		});
+		state.requests.insert(
+			id,
+			PendingRequest {
+				method: method.into(),
+				uri: uri.into(),
+				meta: meta.into(),
+				..Default::default()
+			},
+		);
 		Ok(id)
 	}
 
@@ -275,7 +271,7 @@ impl offchain::Externalities for TestOffchainExt {
 		&mut self,
 		request_id: RequestId,
 		chunk: &[u8],
-		_deadline: Option<Timestamp>
+		_deadline: Option<Timestamp>,
 	) -> Result<(), HttpError> {
 		let mut state = self.0.write();
 
@@ -302,12 +298,14 @@ impl offchain::Externalities for TestOffchainExt {
 	) -> Vec<RequestStatus> {
 		let state = self.0.read();
 
-		ids.iter().map(|id| match state.requests.get(id) {
-			Some(req) if req.response.is_none() =>
-				panic!("No `response` provided for request with id: {:?}", id),
-			None => RequestStatus::Invalid,
-			_ => RequestStatus::Finished(200),
-		}).collect()
+		ids.iter()
+			.map(|id| match state.requests.get(id) {
+				Some(req) if req.response.is_none() =>
+					panic!("No `response` provided for request with id: {:?}", id),
+				None => RequestStatus::Invalid,
+				_ => RequestStatus::Finished(200),
+			})
+			.collect()
 	}
 
 	fn http_response_headers(&mut self, request_id: RequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
@@ -327,11 +325,12 @@ impl offchain::Externalities for TestOffchainExt {
 		&mut self,
 		request_id: RequestId,
 		buffer: &mut [u8],
-		_deadline: Option<Timestamp>
+		_deadline: Option<Timestamp>,
 	) -> Result<usize, HttpError> {
 		let mut state = self.0.write();
 		if let Some(req) = state.requests.get_mut(&request_id) {
-			let response = req.response
+			let response = req
+				.response
 				.as_mut()
 				.unwrap_or_else(|| panic!("No response provided for request: {:?}", request_id));
 
@@ -377,14 +376,14 @@ impl offchain::DbExternalities for TestOffchainExt {
 		kind: StorageKind,
 		key: &[u8],
 		old_value: Option<&[u8]>,
-		new_value: &[u8]
+		new_value: &[u8],
 	) -> bool {
 		let mut state = self.0.write();
 		match kind {
-			StorageKind::LOCAL => state.local_storage
-				.compare_and_set(b"", key, old_value, new_value),
-			StorageKind::PERSISTENT => state.persistent_storage
-				.compare_and_set(b"", key, old_value, new_value),
+			StorageKind::LOCAL =>
+				state.local_storage.compare_and_set(b"", key, old_value, new_value),
+			StorageKind::PERSISTENT =>
+				state.persistent_storage.compare_and_set(b"", key, old_value, new_value),
 		}
 	}