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/frame/uniques/src/benchmarking.rs

@@ -19,22 +19,26 @@
 
 #![cfg(feature = "runtime-benchmarks")]
 
-use sp_std::{prelude::*, convert::TryInto};
 use super::*;
-use sp_runtime::traits::Bounded;
-use frame_system::RawOrigin as SystemOrigin;
 use frame_benchmarking::{
-	benchmarks_instance_pallet, account, whitelisted_caller, whitelist_account, impl_benchmark_test_suite
+	account, benchmarks_instance_pallet, impl_benchmark_test_suite, whitelist_account,
+	whitelisted_caller,
 };
-use frame_support::{traits::{Get, EnsureOrigin}, dispatch::UnfilteredDispatchable, BoundedVec};
+use frame_support::{
+	dispatch::UnfilteredDispatchable,
+	traits::{EnsureOrigin, Get},
+	BoundedVec,
+};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_runtime::traits::Bounded;
+use sp_std::{convert::TryInto, prelude::*};
 
 use crate::Pallet as Uniques;
 
 const SEED: u32 = 0;
 
-fn create_class<T: Config<I>, I: 'static>()
-	-> (T::ClassId, T::AccountId, <T::Lookup as StaticLookup>::Source)
-{
+fn create_class<T: Config<I>, I: 'static>(
+) -> (T::ClassId, T::AccountId, <T::Lookup as StaticLookup>::Source) {
 	let caller: T::AccountId = whitelisted_caller();
 	let caller_lookup = T::Lookup::unlookup(caller.clone());
 	let class = Default::default();
@@ -43,13 +47,13 @@ fn create_class<T: Config<I>, I: 'static>()
 		SystemOrigin::Signed(caller.clone()).into(),
 		class,
 		caller_lookup.clone(),
-	).is_ok());
+	)
+	.is_ok());
 	(class, caller, caller_lookup)
 }
 
-fn add_class_metadata<T: Config<I>, I: 'static>()
-	-> (T::AccountId, <T::Lookup as StaticLookup>::Source)
-{
+fn add_class_metadata<T: Config<I>, I: 'static>(
+) -> (T::AccountId, <T::Lookup as StaticLookup>::Source) {
 	let caller = Class::<T, I>::get(T::ClassId::default()).unwrap().owner;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
@@ -60,13 +64,14 @@ fn add_class_metadata<T: Config<I>, I: 'static>()
 		Default::default(),
 		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
 		false,
-	).is_ok());
+	)
+	.is_ok());
 	(caller, caller_lookup)
 }
 
-fn mint_instance<T: Config<I>, I: 'static>(index: u16)
-	-> (T::InstanceId, T::AccountId, <T::Lookup as StaticLookup>::Source)
-{
+fn mint_instance<T: Config<I>, I: 'static>(
+	index: u16,
+) -> (T::InstanceId, T::AccountId, <T::Lookup as StaticLookup>::Source) {
 	let caller = Class::<T, I>::get(T::ClassId::default()).unwrap().admin;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
@@ -78,13 +83,14 @@ fn mint_instance<T: Config<I>, I: 'static>(index: u16)
 		Default::default(),
 		instance,
 		caller_lookup.clone(),
-	).is_ok());
+	)
+	.is_ok());
 	(instance, caller, caller_lookup)
 }
 
-fn add_instance_metadata<T: Config<I>, I: 'static>(instance: T::InstanceId)
-	-> (T::AccountId, <T::Lookup as StaticLookup>::Source)
-{
+fn add_instance_metadata<T: Config<I>, I: 'static>(
+	instance: T::InstanceId,
+) -> (T::AccountId, <T::Lookup as StaticLookup>::Source) {
 	let caller = Class::<T, I>::get(T::ClassId::default()).unwrap().owner;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
@@ -96,13 +102,14 @@ fn add_instance_metadata<T: Config<I>, I: 'static>(instance: T::InstanceId)
 		instance,
 		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
 		false,
-	).is_ok());
+	)
+	.is_ok());
 	(caller, caller_lookup)
 }
 
-fn add_instance_attribute<T: Config<I>, I: 'static>(instance: T::InstanceId)
-	-> (BoundedVec<u8, T::KeyLimit>, T::AccountId, <T::Lookup as StaticLookup>::Source)
-{
+fn add_instance_attribute<T: Config<I>, I: 'static>(
+	instance: T::InstanceId,
+) -> (BoundedVec<u8, T::KeyLimit>, T::AccountId, <T::Lookup as StaticLookup>::Source) {
 	let caller = Class::<T, I>::get(T::ClassId::default()).unwrap().owner;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
@@ -115,7 +122,8 @@ fn add_instance_attribute<T: Config<I>, I: 'static>(instance: T::InstanceId)
 		Some(instance),
 		key.clone(),
 		vec![0; T::ValueLimit::get() as usize].try_into().unwrap(),
-	).is_ok());
+	)
+	.is_ok());
 	(key, caller, caller_lookup)
 }
 

substrate/frame/uniques/src/functions.rs

@@ -19,7 +19,7 @@
 
 use super::*;
 use frame_support::{ensure, traits::Get};
-use sp_runtime::{DispatchResult, DispatchError};
+use sp_runtime::{DispatchError, DispatchResult};
 
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub(crate) fn do_transfer(
@@ -52,9 +52,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		class: T::ClassId,
 		instance: T::InstanceId,
 		owner: T::AccountId,
-		with_details: impl FnOnce(
-			&ClassDetailsFor<T, I>,
-		) -> DispatchResult,
+		with_details: impl FnOnce(&ClassDetailsFor<T, I>) -> DispatchResult,
 	) -> DispatchResult {
 		ensure!(!Asset::<T, I>::contains_key(class, instance), Error::<T, I>::AlreadyExists);
 
@@ -63,8 +61,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 			with_details(&class_details)?;
 
-			let instances = class_details.instances.checked_add(1)
-				.ok_or(ArithmeticError::Overflow)?;
+			let instances =
+				class_details.instances.checked_add(1).ok_or(ArithmeticError::Overflow)?;
 			class_details.instances = instances;
 
 			let deposit = match class_details.free_holding {
@@ -76,7 +74,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 			let owner = owner.clone();
 			Account::<T, I>::insert((&owner, &class, &instance), ());
-			let details = InstanceDetails { owner, approved: None, is_frozen: false, deposit};
+			let details = InstanceDetails { owner, approved: None, is_frozen: false, deposit };
 			Asset::<T, I>::insert(&class, &instance, details);
 			Ok(())
 		})?;
@@ -88,23 +86,23 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub(super) fn do_burn(
 		class: T::ClassId,
 		instance: T::InstanceId,
-		with_details: impl FnOnce(
-			&ClassDetailsFor<T, I>,
-			&InstanceDetailsFor<T, I>,
-		) -> DispatchResult,
+		with_details: impl FnOnce(&ClassDetailsFor<T, I>, &InstanceDetailsFor<T, I>) -> DispatchResult,
 	) -> DispatchResult {
-		let owner = Class::<T, I>::try_mutate(&class, |maybe_class_details| -> Result<T::AccountId, DispatchError> {
-			let class_details = maybe_class_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
-			let details = Asset::<T, I>::get(&class, &instance)
-				.ok_or(Error::<T, I>::Unknown)?;
-			with_details(&class_details, &details)?;
+		let owner = Class::<T, I>::try_mutate(
+			&class,
+			|maybe_class_details| -> Result<T::AccountId, DispatchError> {
+				let class_details = maybe_class_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+				let details =
+					Asset::<T, I>::get(&class, &instance).ok_or(Error::<T, I>::Unknown)?;
+				with_details(&class_details, &details)?;
 
-			// Return the deposit.
-			T::Currency::unreserve(&class_details.owner, details.deposit);
-			class_details.total_deposit.saturating_reduce(details.deposit);
-			class_details.instances.saturating_dec();
-			Ok(details.owner)
-		})?;
+				// Return the deposit.
+				T::Currency::unreserve(&class_details.owner, details.deposit);
+				class_details.total_deposit.saturating_reduce(details.deposit);
+				class_details.instances.saturating_dec();
+				Ok(details.owner)
+			},
+		)?;
 
 		Asset::<T, I>::remove(&class, &instance);
 		Account::<T, I>::remove((&owner, &class, &instance));

substrate/frame/uniques/src/impl_nonfungibles.rs

@@ -18,10 +18,12 @@
 //! Implementations for `nonfungibles` traits.
 
 use super::*;
-use sp_std::convert::TryFrom;
-use frame_support::traits::tokens::nonfungibles::{Inspect, InspectEnumerable, Mutate, Transfer};
-use frame_support::BoundedSlice;
+use frame_support::{
+	traits::tokens::nonfungibles::{Inspect, InspectEnumerable, Mutate, Transfer},
+	BoundedSlice,
+};
 use sp_runtime::DispatchResult;
+use sp_std::convert::TryFrom;
 
 impl<T: Config<I>, I: 'static> Inspect<<T as SystemConfig>::AccountId> for Pallet<T, I> {
 	type InstanceId = T::InstanceId;
@@ -43,9 +45,11 @@ impl<T: Config<I>, I: 'static> Inspect<<T as SystemConfig>::AccountId> for Palle
 	/// When `key` is empty, we return the instance metadata value.
 	///
 	/// By default this is `None`; no attributes are defined.
-	fn attribute(class: &Self::ClassId, instance: &Self::InstanceId, key: &[u8])
-		-> Option<Vec<u8>>
-	{
+	fn attribute(
+		class: &Self::ClassId,
+		instance: &Self::InstanceId,
+		key: &[u8],
+	) -> Option<Vec<u8>> {
 		if key.is_empty() {
 			// We make the empty key map to the instance metadata value.
 			InstanceMetadataOf::<T, I>::get(class, instance).map(|m| m.data.into())
@@ -60,9 +64,7 @@ impl<T: Config<I>, I: 'static> Inspect<<T as SystemConfig>::AccountId> for Palle
 	/// When `key` is empty, we return the instance metadata value.
 	///
 	/// By default this is `None`; no attributes are defined.
-	fn class_attribute(class: &Self::ClassId, key: &[u8])
-		-> Option<Vec<u8>>
-	{
+	fn class_attribute(class: &Self::ClassId, key: &[u8]) -> Option<Vec<u8>> {
 		if key.is_empty() {
 			// We make the empty key map to the instance metadata value.
 			ClassMetadataOf::<T, I>::get(class).map(|m| m.data.into())
@@ -132,7 +134,10 @@ impl<T: Config<I>, I: 'static> InspectEnumerable<T::AccountId> for Pallet<T, I>
 	/// Returns an iterator of the asset instances of `class` owned by `who`.
 	///
 	/// NOTE: iterating this list invokes a storage read per item.
-	fn owned_in_class(class: &Self::ClassId, who: &T::AccountId) -> Box<dyn Iterator<Item = Self::InstanceId>> {
+	fn owned_in_class(
+		class: &Self::ClassId,
+		who: &T::AccountId,
+	) -> Box<dyn Iterator<Item = Self::InstanceId>> {
 		Box::new(Account::<T, I>::iter_key_prefix((who, class)))
 	}
 }

substrate/frame/uniques/src/lib.rs

@@ -27,33 +27,36 @@
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]
 
-pub mod weights;
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
 #[cfg(test)]
 pub mod mock;
 #[cfg(test)]
 mod tests;
+pub mod weights;
 
-mod types;
 mod functions;
 mod impl_nonfungibles;
+mod types;
 pub use types::*;
 
-use sp_std::prelude::*;
-use sp_runtime::{RuntimeDebug, ArithmeticError, traits::{Zero, StaticLookup, Saturating}};
-use codec::{Encode, Decode, HasCompact};
-use frame_support::traits::{Currency, ReservableCurrency, BalanceStatus::Reserved};
+use codec::{Decode, Encode, HasCompact};
+use frame_support::traits::{BalanceStatus::Reserved, Currency, ReservableCurrency};
 use frame_system::Config as SystemConfig;
+use sp_runtime::{
+	traits::{Saturating, StaticLookup, Zero},
+	ArithmeticError, RuntimeDebug,
+};
+use sp_std::prelude::*;
 
-pub use weights::WeightInfo;
 pub use pallet::*;
+pub use weights::WeightInfo;
 
 #[frame_support::pallet]
 pub mod pallet {
+	use super::*;
 	use frame_support::pallet_prelude::*;
 	use frame_system::pallet_prelude::*;
-	use super::*;
 
 	#[pallet::pallet]
 	#[pallet::generate_store(pub(super) trait Store)]
@@ -182,7 +185,7 @@ pub mod pallet {
 			NMapKey<Blake2_128Concat, BoundedVec<u8, T::KeyLimit>>,
 		),
 		(BoundedVec<u8, T::ValueLimit>, DepositBalanceOf<T, I>),
-		OptionQuery
+		OptionQuery,
 	>;
 
 	#[pallet::event]
@@ -190,7 +193,7 @@ pub mod pallet {
 	#[pallet::metadata(
 		T::AccountId = "AccountId",
 		T::ClassId = "ClassId",
-		T::InstanceId = "InstanceId",
+		T::InstanceId = "InstanceId"
 	)]
 	pub enum Event<T: Config<I>, I: 'static = ()> {
 		/// An asset class was created. \[ class, creator, owner \]
@@ -419,7 +422,10 @@ pub mod pallet {
 					ensure!(class_details.owner == check_owner, Error::<T, I>::NoPermission);
 				}
 				ensure!(class_details.instances == witness.instances, Error::<T, I>::BadWitness);
-				ensure!(class_details.instance_metadatas == witness.instance_metadatas, Error::<T, I>::BadWitness);
+				ensure!(
+					class_details.instance_metadatas == witness.instance_metadatas,
+					Error::<T, I>::BadWitness
+				);
 				ensure!(class_details.attributes == witness.attributes, Error::<T, I>::BadWitness);
 
 				for (instance, details) in Asset::<T, I>::drain_prefix(&class) {
@@ -490,7 +496,10 @@ pub mod pallet {
 			Self::do_burn(class, instance, |class_details, details| {
 				let is_permitted = class_details.admin == origin || details.owner == origin;
 				ensure!(is_permitted, Error::<T, I>::NoPermission);
-				ensure!(check_owner.map_or(true, |o| o == details.owner), Error::<T, I>::WrongOwner);
+				ensure!(
+					check_owner.map_or(true, |o| o == details.owner),
+					Error::<T, I>::WrongOwner
+				);
 				Ok(())
 			})
 		}
@@ -610,8 +619,8 @@ pub mod pallet {
 		) -> DispatchResult {
 			let origin = ensure_signed(origin)?;
 
-			let mut details = Asset::<T, I>::get(&class, &instance)
-				.ok_or(Error::<T, I>::Unknown)?;
+			let mut details =
+				Asset::<T, I>::get(&class, &instance).ok_or(Error::<T, I>::Unknown)?;
 			let class_details = Class::<T, I>::get(&class).ok_or(Error::<T, I>::Unknown)?;
 			ensure!(class_details.freezer == origin, Error::<T, I>::NoPermission);
 
@@ -640,8 +649,8 @@ pub mod pallet {
 		) -> DispatchResult {
 			let origin = ensure_signed(origin)?;
 
-			let mut details = Asset::<T, I>::get(&class, &instance)
-				.ok_or(Error::<T, I>::Unknown)?;
+			let mut details =
+				Asset::<T, I>::get(&class, &instance).ok_or(Error::<T, I>::Unknown)?;
 			let class_details = Class::<T, I>::get(&class).ok_or(Error::<T, I>::Unknown)?;
 			ensure!(class_details.admin == origin, Error::<T, I>::NoPermission);
 
@@ -664,7 +673,7 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::freeze_class())]
 		pub fn freeze_class(
 			origin: OriginFor<T>,
-			#[pallet::compact] class: T::ClassId
+			#[pallet::compact] class: T::ClassId,
 		) -> DispatchResult {
 			let origin = ensure_signed(origin)?;
 
@@ -691,7 +700,7 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::thaw_class())]
 		pub fn thaw_class(
 			origin: OriginFor<T>,
-			#[pallet::compact] class: T::ClassId
+			#[pallet::compact] class: T::ClassId,
 		) -> DispatchResult {
 			let origin = ensure_signed(origin)?;
 
@@ -729,7 +738,7 @@ pub mod pallet {
 				let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
 				ensure!(&origin == &details.owner, Error::<T, I>::NoPermission);
 				if details.owner == owner {
-					return Ok(());
+					return Ok(())
 				}
 
 				// Move the deposit to the new owner.
@@ -809,8 +818,8 @@ pub mod pallet {
 			let delegate = T::Lookup::lookup(delegate)?;
 
 			let class_details = Class::<T, I>::get(&class).ok_or(Error::<T, I>::Unknown)?;
-			let mut details = Asset::<T, I>::get(&class, &instance)
-				.ok_or(Error::<T, I>::Unknown)?;
+			let mut details =
+				Asset::<T, I>::get(&class, &instance).ok_or(Error::<T, I>::Unknown)?;
 
 			if let Some(check) = maybe_check {
 				let permitted = &check == &class_details.admin || &check == &details.owner;
@@ -854,8 +863,8 @@ pub mod pallet {
 				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
 
 			let class_details = Class::<T, I>::get(&class).ok_or(Error::<T, I>::Unknown)?;
-			let mut details = Asset::<T, I>::get(&class, &instance)
-				.ok_or(Error::<T, I>::Unknown)?;
+			let mut details =
+				Asset::<T, I>::get(&class, &instance).ok_or(Error::<T, I>::Unknown)?;
 			if let Some(check) = maybe_check {
 				let permitted = &check == &class_details.admin || &check == &details.owner;
 				ensure!(permitted, Error::<T, I>::NoPermission);
@@ -1060,8 +1069,7 @@ pub mod pallet {
 				.map(|_| None)
 				.or_else(|origin| ensure_signed(origin).map(Some))?;
 
-			let mut class_details = Class::<T, I>::get(&class)
-				.ok_or(Error::<T, I>::Unknown)?;
+			let mut class_details = Class::<T, I>::get(&class).ok_or(Error::<T, I>::Unknown)?;
 
 			if let Some(check_owner) = &maybe_check_owner {
 				ensure!(check_owner == &class_details.owner, Error::<T, I>::NoPermission);
@@ -1089,11 +1097,7 @@ pub mod pallet {
 				}
 				class_details.total_deposit.saturating_accrue(deposit);
 
-				*metadata = Some(InstanceMetadata {
-					deposit,
-					data: data.clone(),
-					is_frozen,
-				});
+				*metadata = Some(InstanceMetadata { deposit, data: data.clone(), is_frozen });
 
 				Class::<T, I>::insert(&class, &class_details);
 				Self::deposit_event(Event::MetadataSet(class, instance, data, is_frozen));
@@ -1124,8 +1128,7 @@ pub mod pallet {
 				.map(|_| None)
 				.or_else(|origin| ensure_signed(origin).map(Some))?;
 
-			let mut class_details = Class::<T, I>::get(&class)
-				.ok_or(Error::<T, I>::Unknown)?;
+			let mut class_details = Class::<T, I>::get(&class).ok_or(Error::<T, I>::Unknown)?;
 			if let Some(check_owner) = &maybe_check_owner {
 				ensure!(check_owner == &class_details.owner, Error::<T, I>::NoPermission);
 			}
@@ -1200,11 +1203,7 @@ pub mod pallet {
 
 				Class::<T, I>::insert(&class, details);
 
-				*metadata = Some(ClassMetadata {
-					deposit,
-					data: data.clone(),
-					is_frozen,
-				});
+				*metadata = Some(ClassMetadata { deposit, data: data.clone(), is_frozen });
 
 				Self::deposit_event(Event::ClassMetadataSet(class, data, is_frozen));
 				Ok(())

substrate/frame/uniques/src/mock.rs

@@ -20,9 +20,12 @@
 use super::*;
 use crate as pallet_uniques;
 
+use frame_support::{construct_runtime, parameter_types};
 use sp_core::H256;
-use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::Header};
-use frame_support::{parameter_types, construct_runtime};
+use sp_runtime::{
+	testing::Header,
+	traits::{BlakeTwo256, IdentityLookup},
+};
 
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
 type Block = frame_system::mocking::MockBlock<Test>;

substrate/frame/uniques/src/tests.rs

@@ -19,9 +19,9 @@
 
 use super::*;
 use crate::mock::*;
-use sp_std::convert::TryInto;
-use frame_support::{assert_ok, assert_noop, traits::Currency};
+use frame_support::{assert_noop, assert_ok, traits::Currency};
 use pallet_balances::Error as BalancesError;
+use sp_std::convert::TryInto;
 
 fn assets() -> Vec<(u64, u32, u32)> {
 	let mut r: Vec<_> = Account::<Test>::iter().map(|x| x.0).collect();
@@ -31,13 +31,15 @@ fn assets() -> Vec<(u64, u32, u32)> {
 	assert_eq!(r, s);
 	for class in Asset::<Test>::iter()
 		.map(|x| x.0)
-		.scan(None, |s, item| if s.map_or(false, |last| last == item) {
+		.scan(None, |s, item| {
+			if s.map_or(false, |last| last == item) {
 				*s = Some(item);
 				Some(None)
 			} else {
 				Some(Some(item))
 			}
-		).filter_map(|item| item)
+		})
+		.filter_map(|item| item)
 	{
 		let details = Class::<Test>::get(class).unwrap();
 		let instances = Asset::<Test>::iter_prefix(class).count() as u32;
@@ -181,7 +183,10 @@ fn origin_guards_should_work() {
 	new_test_ext().execute_with(|| {
 		assert_ok!(Uniques::force_create(Origin::root(), 0, 1, true));
 		assert_ok!(Uniques::mint(Origin::signed(1), 0, 42, 1));
-		assert_noop!(Uniques::transfer_ownership(Origin::signed(2), 0, 2), Error::<Test>::NoPermission);
+		assert_noop!(
+			Uniques::transfer_ownership(Origin::signed(2), 0, 2),
+			Error::<Test>::NoPermission
+		);
 		assert_noop!(Uniques::set_team(Origin::signed(2), 0, 2, 2, 2), Error::<Test>::NoPermission);
 		assert_noop!(Uniques::freeze(Origin::signed(2), 0, 42), Error::<Test>::NoPermission);
 		assert_noop!(Uniques::thaw(Origin::signed(2), 0, 42), Error::<Test>::NoPermission);
@@ -205,7 +210,10 @@ fn transfer_owner_should_work() {
 		assert_eq!(Balances::reserved_balance(&1), 0);
 		assert_eq!(Balances::reserved_balance(&2), 2);
 
-		assert_noop!(Uniques::transfer_ownership(Origin::signed(1), 0, 1), Error::<Test>::NoPermission);
+		assert_noop!(
+			Uniques::transfer_ownership(Origin::signed(1), 0, 1),
+			Error::<Test>::NoPermission
+		);
 
 		// Mint and set metadata now and make sure that deposit gets transferred back.
 		assert_ok!(Uniques::set_class_metadata(Origin::signed(2), 0, bvec![0u8; 20], false));
@@ -279,7 +287,10 @@ fn set_class_metadata_should_work() {
 
 		// Clear Metadata
 		assert_ok!(Uniques::set_class_metadata(Origin::root(), 0, bvec![0u8; 15], false));
-		assert_noop!(Uniques::clear_class_metadata(Origin::signed(2), 0), Error::<Test>::NoPermission);
+		assert_noop!(
+			Uniques::clear_class_metadata(Origin::signed(2), 0),
+			Error::<Test>::NoPermission
+		);
 		assert_noop!(Uniques::clear_class_metadata(Origin::signed(1), 1), Error::<Test>::Unknown);
 		assert_ok!(Uniques::clear_class_metadata(Origin::signed(1), 0));
 		assert!(!ClassMetadataOf::<Test>::contains_key(0));
@@ -330,7 +341,10 @@ fn set_instance_metadata_should_work() {
 
 		// Clear Metadata
 		assert_ok!(Uniques::set_metadata(Origin::root(), 0, 42, bvec![0u8; 15], false));
-		assert_noop!(Uniques::clear_metadata(Origin::signed(2), 0, 42), Error::<Test>::NoPermission);
+		assert_noop!(
+			Uniques::clear_metadata(Origin::signed(2), 0, 42),
+			Error::<Test>::NoPermission
+		);
 		assert_noop!(Uniques::clear_metadata(Origin::signed(1), 1, 42), Error::<Test>::Unknown);
 		assert_ok!(Uniques::clear_metadata(Origin::signed(1), 0, 42));
 		assert!(!InstanceMetadataOf::<Test>::contains_key(0, 42));
@@ -347,26 +361,32 @@ fn set_attribute_should_work() {
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, None, bvec![0], bvec![0]));
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, Some(0), bvec![0], bvec![0]));
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, Some(0), bvec![1], bvec![0]));
-		assert_eq!(attributes(0), vec![
-			(None, bvec![0], bvec![0]),
-			(Some(0), bvec![0], bvec![0]),
-			(Some(0), bvec![1], bvec![0]),
-		]);
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, bvec![0], bvec![0]),
+				(Some(0), bvec![0], bvec![0]),
+				(Some(0), bvec![1], bvec![0]),
+			]
+		);
 		assert_eq!(Balances::reserved_balance(1), 9);
 
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, None, bvec![0], bvec![0; 10]));
-		assert_eq!(attributes(0), vec![
-			(None, bvec![0], bvec![0; 10]),
-			(Some(0), bvec![0], bvec![0]),
-			(Some(0), bvec![1], bvec![0]),
-		]);
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, bvec![0], bvec![0; 10]),
+				(Some(0), bvec![0], bvec![0]),
+				(Some(0), bvec![1], bvec![0]),
+			]
+		);
 		assert_eq!(Balances::reserved_balance(1), 18);
 
 		assert_ok!(Uniques::clear_attribute(Origin::signed(1), 0, Some(0), bvec![1]));
-		assert_eq!(attributes(0), vec![
-			(None, bvec![0], bvec![0; 10]),
-			(Some(0), bvec![0], bvec![0]),
-		]);
+		assert_eq!(
+			attributes(0),
+			vec![(None, bvec![0], bvec![0; 10]), (Some(0), bvec![0], bvec![0]),]
+		);
 		assert_eq!(Balances::reserved_balance(1), 15);
 
 		let w = Class::<Test>::get(0).unwrap().destroy_witness();
@@ -386,11 +406,14 @@ fn set_attribute_should_respect_freeze() {
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, None, bvec![0], bvec![0]));
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, Some(0), bvec![0], bvec![0]));
 		assert_ok!(Uniques::set_attribute(Origin::signed(1), 0, Some(1), bvec![0], bvec![0]));
-		assert_eq!(attributes(0), vec![
-			(None, bvec![0], bvec![0]),
-			(Some(0), bvec![0], bvec![0]),
-			(Some(1), bvec![0], bvec![0]),
-		]);
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, bvec![0], bvec![0]),
+				(Some(0), bvec![0], bvec![0]),
+				(Some(1), bvec![0], bvec![0]),
+			]
+		);
 		assert_eq!(Balances::reserved_balance(1), 9);
 
 		assert_ok!(Uniques::set_class_metadata(Origin::signed(1), 0, bvec![], true));
@@ -406,7 +429,7 @@ fn set_attribute_should_respect_freeze() {
 }
 
 #[test]
-fn force_asset_status_should_work(){
+fn force_asset_status_should_work() {
 	new_test_ext().execute_with(|| {
 		Balances::make_free_balance_be(&1, 100);
 
@@ -418,7 +441,7 @@ fn force_asset_status_should_work(){
 		assert_ok!(Uniques::set_metadata(Origin::signed(1), 0, 69, bvec![0; 20], false));
 		assert_eq!(Balances::reserved_balance(1), 65);
 
-		//force asset status to be free holding
+		// force asset status to be free holding
 		assert_ok!(Uniques::force_asset_status(Origin::root(), 0, 1, 1, 1, 1, true, false));
 		assert_ok!(Uniques::mint(Origin::signed(1), 0, 142, 1));
 		assert_ok!(Uniques::mint(Origin::signed(1), 0, 169, 2));
@@ -484,13 +507,28 @@ fn cancel_approval_works() {
 		assert_ok!(Uniques::mint(Origin::signed(1), 0, 42, 2));
 
 		assert_ok!(Uniques::approve_transfer(Origin::signed(2), 0, 42, 3));
-		assert_noop!(Uniques::cancel_approval(Origin::signed(2), 1, 42, None), Error::<Test>::Unknown);
-		assert_noop!(Uniques::cancel_approval(Origin::signed(2), 0, 43, None), Error::<Test>::Unknown);
-		assert_noop!(Uniques::cancel_approval(Origin::signed(3), 0, 42, None), Error::<Test>::NoPermission);
-		assert_noop!(Uniques::cancel_approval(Origin::signed(2), 0, 42, Some(4)), Error::<Test>::WrongDelegate);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(2), 1, 42, None),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(2), 0, 43, None),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(3), 0, 42, None),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(2), 0, 42, Some(4)),
+			Error::<Test>::WrongDelegate
+		);
 
 		assert_ok!(Uniques::cancel_approval(Origin::signed(2), 0, 42, Some(3)));
-		assert_noop!(Uniques::cancel_approval(Origin::signed(2), 0, 42, None), Error::<Test>::NoDelegate);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(2), 0, 42, None),
+			Error::<Test>::NoDelegate
+		);
 	});
 }
 
@@ -501,12 +539,24 @@ fn cancel_approval_works_with_admin() {
 		assert_ok!(Uniques::mint(Origin::signed(1), 0, 42, 2));
 
 		assert_ok!(Uniques::approve_transfer(Origin::signed(2), 0, 42, 3));
-		assert_noop!(Uniques::cancel_approval(Origin::signed(1), 1, 42, None), Error::<Test>::Unknown);
-		assert_noop!(Uniques::cancel_approval(Origin::signed(1), 0, 43, None), Error::<Test>::Unknown);
-		assert_noop!(Uniques::cancel_approval(Origin::signed(1), 0, 42, Some(4)), Error::<Test>::WrongDelegate);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(1), 1, 42, None),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(1), 0, 43, None),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(1), 0, 42, Some(4)),
+			Error::<Test>::WrongDelegate
+		);
 
 		assert_ok!(Uniques::cancel_approval(Origin::signed(1), 0, 42, Some(3)));
-		assert_noop!(Uniques::cancel_approval(Origin::signed(1), 0, 42, None), Error::<Test>::NoDelegate);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::signed(1), 0, 42, None),
+			Error::<Test>::NoDelegate
+		);
 	});
 }
 
@@ -519,9 +569,15 @@ fn cancel_approval_works_with_force() {
 		assert_ok!(Uniques::approve_transfer(Origin::signed(2), 0, 42, 3));
 		assert_noop!(Uniques::cancel_approval(Origin::root(), 1, 42, None), Error::<Test>::Unknown);
 		assert_noop!(Uniques::cancel_approval(Origin::root(), 0, 43, None), Error::<Test>::Unknown);
-		assert_noop!(Uniques::cancel_approval(Origin::root(), 0, 42, Some(4)), Error::<Test>::WrongDelegate);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::root(), 0, 42, Some(4)),
+			Error::<Test>::WrongDelegate
+		);
 
 		assert_ok!(Uniques::cancel_approval(Origin::root(), 0, 42, Some(3)));
-		assert_noop!(Uniques::cancel_approval(Origin::root(), 0, 42, None), Error::<Test>::NoDelegate);
+		assert_noop!(
+			Uniques::cancel_approval(Origin::root(), 0, 42, None),
+			Error::<Test>::NoDelegate
+		);
 	});
 }

substrate/frame/uniques/src/types.rs

@@ -27,12 +27,8 @@ pub(super) type ClassDetailsFor<T, I> =
 pub(super) type InstanceDetailsFor<T, I> =
 	InstanceDetails<<T as SystemConfig>::AccountId, DepositBalanceOf<T, I>>;
 
-
 #[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug)]
-pub struct ClassDetails<
-	AccountId,
-	DepositBalance,
-> {
+pub struct ClassDetails<AccountId, DepositBalance> {
 	/// Can change `owner`, `issuer`, `freezer` and `admin` accounts.
 	pub(super) owner: AccountId,
 	/// Can mint tokens.

substrate/frame/uniques/src/weights.rs

@@ -36,6 +36,7 @@
 // --template=./.maintain/frame-weight-template.hbs
 
 
+#![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
 #![allow(unused_imports)]