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: tcharding

examples/parse.rs

@@ -19,7 +19,8 @@ extern crate miniscript;
 
 use std::str::FromStr;
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+use miniscript::descriptor::DescriptorType;
+use miniscript::{Descriptor, DescriptorTrait};
 
 fn main() {
     let my_descriptor = 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,9 +18,11 @@
 //! 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 expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
@@ -30,10 +32,8 @@ use {
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::DescriptorTrait;
 
 /// Create a Bare Descriptor. That is descriptor that is
 /// not wrapped in sh or wsh. This covers the Pk descriptor

src/descriptor/key.rs

@@ -1,14 +1,11 @@
-use std::{error, fmt, str::FromStr};
-
-use bitcoin::{
-    self,
-    hashes::Hash,
-    hashes::{hex::FromHex, HashEngine},
-    secp256k1,
-    secp256k1::{Secp256k1, Signing},
-    util::bip32,
-    XOnlyPublicKey, XpubIdentifier,
-};
+use std::str::FromStr;
+use std::{error, fmt};
+
+use bitcoin::hashes::hex::FromHex;
+use bitcoin::hashes::{Hash, HashEngine};
+use bitcoin::secp256k1::{Secp256k1, Signing};
+use bitcoin::util::bip32;
+use bitcoin::{self, secp256k1, XOnlyPublicKey, XpubIdentifier};
 use {MiniscriptKey, ToPublicKey};
 
 /// Single public key without any origin or range information

src/descriptor/mod.rs

@@ -23,20 +23,17 @@
 //! these with BIP32 paths, pay-to-contract instructions, etc.
 //!
 
-use std::{collections::HashMap, sync::Arc};
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::collections::HashMap;
+use std::fmt;
+use std::str::{self, FromStr};
+use std::sync::Arc;
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::{self, secp256k1, Script};
-use expression;
-use miniscript;
 use miniscript::{Legacy, Miniscript, Segwitv0};
 use {
-    BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
-    TranslatePk2,
+    expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslatePk, TranslatePk2,
 };
 
 use self::checksum::verify_checksum;
@@ -839,10 +836,9 @@ mod tests {
     use descriptor::{
         DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePub, DescriptorXKey,
     };
-    use hex_script;
     #[cfg(feature = "compiler")]
     use policy;
-    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    use {hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
 
     use super::checksum::desc_checksum;
     use super::tr::Tr;

src/descriptor/pretaproot.rs

@@ -1,12 +1,11 @@
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::fmt;
+use std::str::{self, FromStr};
 
 use bitcoin::{self, Script};
 use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
-use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
+use super::checksum::verify_checksum;
+use super::{Bare, Pkh, Sh, Wpkh, Wsh};
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -240,10 +239,8 @@ serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor");
 // Have the trait in a separate module to avoid conflicts
 pub(crate) mod traits {
     use bitcoin::Script;
-    use {
-        descriptor::{Pkh, Sh, Wpkh, Wsh},
-        DescriptorTrait, MiniscriptKey, ToPublicKey,
-    };
+    use descriptor::{Pkh, Sh, Wpkh, Wsh};
+    use {DescriptorTrait, MiniscriptKey, ToPublicKey};
 
     use super::PreTaprootDescriptor;
 

src/descriptor/segwitv0.rs

@@ -16,7 +16,8 @@
 //! 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 expression::{self, FromTree};
@@ -28,10 +29,8 @@ use {
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec};
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct Wsh<Pk: MiniscriptKey> {

src/descriptor/sh.rs

@@ -18,23 +18,22 @@
 //! 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 expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
-use push_opcode_size;
 use util::{varint_len, witness_to_scriptsig};
 use {
-    Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslatePk,
+    push_opcode_size, Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier,
+    Segwitv0, ToPublicKey, TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec, Wpkh, Wsh};
 
 /// A Legacy p2sh Descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]

src/descriptor/sortedmulti.rs

@@ -16,16 +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 expression;
-use miniscript::{
-    self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
+use miniscript::context::ScriptContext;
+use miniscript::decode::Terminal;
+use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
+use {
+    errstr, expression, miniscript, policy, script_num_size, Error, ForEach, ForEachKey,
+    Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
 };
-use policy;
-use script_num_size;
-use {errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Contents of a "sortedmulti" descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

src/descriptor/tr.rs

@@ -1,25 +1,25 @@
 // 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::{
     LeafVersion, TaprootBuilder, TaprootBuilderError, TaprootSpendInfo, TAPROOT_CONTROL_BASE_SIZE,
     TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
 };
 use bitcoin::{self, secp256k1, Script};
-use errstr;
 use expression::{self, FromTree};
 use miniscript::Miniscript;
 use policy::semantic::Policy;
 use policy::Liftable;
 use util::{varint_len, witness_size};
-use Tap;
-use {DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
-use {Error, MiniscriptKey};
+use {
+    errstr, DescriptorTrait, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, Tap,
+    ToPublicKey, TranslatePk,
+};
 
 use super::checksum::{desc_checksum, verify_checksum};