Configure imports_granularity

Configure `imports_granularity = "Module"`.

The benefit of this option is that it increases uniformity in the code
base over the default "Preserve" and also, from my personal experience,
it tends to reduce the noise in diffs from adding/removing imports.

Author: heap-coder

examples/parse.rs

@@ -16,7 +16,8 @@
 
 use std::str::FromStr;
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+use miniscript::descriptor::DescriptorType;
+use miniscript::{Descriptor, DescriptorTrait};
 
 fn main() {
     let desc = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(

rustfmt.toml

@@ -27,7 +27,7 @@ fn_single_line = false
 where_single_line = false
 imports_indent = "Block"
 imports_layout = "Mixed"
-imports_granularity = "Preserve"
+imports_granularity = "Module"     # Default "Preserve"
 group_imports = "StdExternalCrate" # Default "Preserve"
 reorder_imports = true
 reorder_modules = true

src/descriptor/bare.rs

@@ -18,14 +18,14 @@
 //! Also includes pk, and pkh descriptors
 //!
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
-use bitcoin::{self, blockdata::script, Script};
+use bitcoin::blockdata::script;
+use bitcoin::{self, Script};
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::DescriptorTrait;
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};

src/descriptor/key.rs

@@ -1,13 +1,11 @@
-use std::{error, fmt, str::FromStr};
-
-use bitcoin::{
-    self,
-    hashes::{hash160, Hash},
-    hashes::{hex::FromHex, HashEngine},
-    secp256k1::{Secp256k1, Signing, Verification},
-    util::bip32,
-    XOnlyPublicKey, XpubIdentifier,
-};
+use std::str::FromStr;
+use std::{error, fmt};
+
+use bitcoin::hashes::hex::FromHex;
+use bitcoin::hashes::{hash160, Hash, HashEngine};
+use bitcoin::secp256k1::{Secp256k1, Signing, Verification};
+use bitcoin::util::bip32;
+use bitcoin::{self, XOnlyPublicKey, XpubIdentifier};
 
 use crate::{MiniscriptKey, ToPublicKey};
 

src/descriptor/mod.rs

@@ -23,24 +23,21 @@
 //! these with BIP32 paths, pay-to-contract instructions, etc.
 //!
 
+use std::collections::HashMap;
+use std::fmt;
 use std::ops::Range;
-use std::{collections::HashMap, sync::Arc};
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::str::{self, FromStr};
+use std::sync::Arc;
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::util::address::WitnessVersion;
 use bitcoin::{self, secp256k1, Script};
 
 use self::checksum::verify_checksum;
-use crate::expression;
-use crate::miniscript;
 use crate::miniscript::{Legacy, Miniscript, Segwitv0};
 use crate::{
-    BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
-    TranslatePk2,
+    expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslatePk, TranslatePk2,
 };
 
 // Directly export from lib.rs, exporting the trait here causes conflicts in this file
@@ -874,10 +871,9 @@ mod tests {
     use super::*;
     use crate::descriptor::key::Wildcard;
     use crate::descriptor::{DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey, SinglePub};
-    use crate::hex_script;
     #[cfg(feature = "compiler")]
     use crate::policy;
-    use crate::{Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    use crate::{hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
 
     type StdDescriptor = Descriptor<PublicKey>;
     const TEST_PK: &'static str =

src/descriptor/pretaproot.rs

@@ -1,11 +1,10 @@
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::fmt;
+use std::str::{self, FromStr};
 
 use bitcoin::{self, Script};
 
-use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
+use super::checksum::verify_checksum;
+use super::{Bare, Pkh, Sh, Wpkh, Wsh};
 use crate::{expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Script descriptor
@@ -242,10 +241,8 @@ pub(crate) mod traits {
     use bitcoin::Script;
 
     use super::PreTaprootDescriptor;
-    use crate::{
-        descriptor::{Pkh, Sh, Wpkh, Wsh},
-        DescriptorTrait, MiniscriptKey, ToPublicKey,
-    };
+    use crate::descriptor::{Pkh, Sh, Wpkh, Wsh};
+    use crate::{DescriptorTrait, MiniscriptKey, ToPublicKey};
 
     /// A general trait for Pre taproot bitcoin descriptor.
     /// Similar to [`DescriptorTrait`], but `explicit_script` and `script_code` methods cannot fail

src/descriptor/segwitv0.rs

@@ -16,14 +16,13 @@
 //! Implementation of Segwit Descriptors. Contains the implementation
 //! of wsh, wpkh and sortedmulti inside wsh.
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
 use bitcoin::{self, Script};
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::{ScriptContext, ScriptContextError};
 use crate::policy::{semantic, Liftable};

src/descriptor/sh.rs

@@ -18,22 +18,21 @@
 //! sh(miniscript), and sh(wpkh)
 //!
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
-use bitcoin::{self, blockdata::script, Script};
+use bitcoin::blockdata::script;
+use bitcoin::{self, Script};
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec, Wpkh, Wsh};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
-use crate::push_opcode_size;
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslatePk,
+    push_opcode_size, Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier,
+    Segwitv0, ToPublicKey, TranslatePk,
 };
 
 /// A Legacy p2sh Descriptor

src/descriptor/sortedmulti.rs

@@ -16,18 +16,18 @@
 //! Implementation of sorted multi primitive for descriptors
 //!
 
-use std::{fmt, marker::PhantomData, str::FromStr};
+use std::fmt;
+use std::marker::PhantomData;
+use std::str::FromStr;
 
 use bitcoin::blockdata::script;
 
-use crate::expression;
-use crate::miniscript::{
-    self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
-};
-use crate::policy;
-use crate::script_num_size;
+use crate::miniscript::context::ScriptContext;
+use crate::miniscript::decode::Terminal;
+use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use crate::{
-    errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
+    errstr, expression, miniscript, policy, script_num_size, Error, ForEach, ForEachKey,
+    Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
 };
 
 /// Contents of a "sortedmulti" descriptor

src/descriptor/tr.rs

@@ -1,9 +1,9 @@
 // Tapscript
 
 use std::cmp::{self, max};
-use std::hash;
+use std::str::FromStr;
 use std::sync::{Arc, Mutex};
-use std::{fmt, str::FromStr};
+use std::{fmt, hash};
 
 use bitcoin::blockdata::opcodes;
 use bitcoin::util::taproot::{
@@ -13,15 +13,15 @@ use bitcoin::util::taproot::{
 use bitcoin::{self, secp256k1, Script};
 
 use super::checksum::{desc_checksum, verify_checksum};
-use crate::errstr;
 use crate::expression::{self, FromTree};
 use crate::miniscript::Miniscript;
 use crate::policy::semantic::Policy;
 use crate::policy::Liftable;
 use crate::util::{varint_len, witness_size};
-use crate::Tap;
-use crate::{DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
-use crate::{Error, MiniscriptKey};
+use crate::{
+    errstr, DescriptorTrait, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, Tap,
+    ToPublicKey, TranslatePk,
+};
 
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should