Configure group_imports

Configure `group_imports = "StdExternalCrate"`.

The benefit of this option is that it increases uniformity in the code
base over the default "Preserve", while saving devs needing to think
about where they place their import statements (for those that do not
use tooling to add them).

examples/htlc.rs

@@ -17,11 +17,12 @@
 extern crate bitcoin;
 extern crate miniscript;
 
+use std::str::FromStr;
+
 use bitcoin::Network;
 use miniscript::descriptor::Wsh;
 use miniscript::policy::{Concrete, Liftable};
 use miniscript::DescriptorTrait;
-use std::str::FromStr;
 
 fn main() {
     //HTLC policy with 10:1 odds for happy(co-operative) case compared to uncooperative case

examples/parse.rs

@@ -17,9 +17,10 @@
 extern crate bitcoin;
 extern crate miniscript;
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
 use std::str::FromStr;
 
+use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+
 fn main() {
     let my_descriptor = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(
         "wsh(c:pk_k(020202020202020202020202020202020202020202020202020202020202020202))",

examples/sign_multisig.rs

@@ -17,11 +17,12 @@
 extern crate bitcoin;
 extern crate miniscript;
 
+use std::collections::HashMap;
+use std::str::FromStr;
+
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::secp256k1; // secp256k1 re-exported from rust-bitcoin
 use miniscript::DescriptorTrait;
-use std::collections::HashMap;
-use std::str::FromStr;
 
 fn main() {
     // Avoid repeatedly typing a pretty-common descriptor type

examples/verify_tx.rs

@@ -17,11 +17,12 @@
 extern crate bitcoin;
 extern crate miniscript;
 
+use std::str::FromStr;
+
 use bitcoin::consensus::Decodable;
 use bitcoin::util::sighash;
 use bitcoin::{secp256k1, TxOut}; // secp256k1 re-exported from rust-bitcoin
 use miniscript::interpreter::KeySigPair;
-use std::str::FromStr;
 
 fn main() {
     // tx `f27eba163c38ad3f34971198687a3f1882b7ec818599ffe469a8440d82261c98`

examples/xpub_descriptors.rs

@@ -16,10 +16,10 @@
 
 extern crate miniscript;
 
+use std::str::FromStr;
+
 use miniscript::bitcoin::{self, secp256k1};
 use miniscript::{Descriptor, DescriptorPublicKey, DescriptorTrait, TranslatePk2};
-
-use std::str::FromStr;
 fn main() {
     // For deriving from descriptors, we need to provide a secp context
     let secp_ctx = secp256k1::Secp256k1::verification_only();

rustfmt.toml

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

src/descriptor/bare.rs

@@ -21,7 +21,6 @@
 use std::{fmt, str::FromStr};
 
 use bitcoin::{self, blockdata::script, Script};
-
 use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};

src/descriptor/checksum.rs

@@ -101,9 +101,10 @@ pub(super) fn verify_checksum(s: &str) -> Result<&str, Error> {
 }
 #[cfg(test)]
 mod test {
-    use super::*;
     use std::str;
 
+    use super::*;
+
     macro_rules! check_expected {
         ($desc: expr, $checksum: expr) => {
             assert_eq!(desc_checksum($desc).unwrap(), $checksum);

src/descriptor/key.rs

@@ -9,7 +9,6 @@ use bitcoin::{
     util::bip32,
     XOnlyPublicKey, XpubIdentifier,
 };
-
 use {MiniscriptKey, ToPublicKey};
 
 /// Single public key without any origin or range information
@@ -719,11 +718,11 @@ impl MiniscriptKey for DescriptorPublicKey {
 
 #[cfg(test)]
 mod test {
-    use super::{DescriptorKeyParseError, DescriptorPublicKey, DescriptorSecretKey};
+    use std::str::FromStr;
 
     use bitcoin::secp256k1;
 
-    use std::str::FromStr;
+    use super::{DescriptorKeyParseError, DescriptorPublicKey, DescriptorSecretKey};
 
     #[test]
     fn parse_descriptor_key_errors() {

src/descriptor/mod.rs

@@ -31,8 +31,6 @@ use std::{
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::{self, secp256k1, Script};
-
-use self::checksum::verify_checksum;
 use expression;
 use miniscript;
 use miniscript::{Legacy, Miniscript, Segwitv0};
@@ -41,6 +39,8 @@ use {
     TranslatePk2,
 };
 
+use self::checksum::verify_checksum;
+
 // Directly export from lib.rs, exporting the trait here causes conflicts in this file
 pub(crate) mod pretaproot;
 
@@ -824,9 +824,10 @@ serde_string_impl_pk!(Descriptor, "a script descriptor");
 
 #[cfg(test)]
 mod tests {
-    use super::checksum::desc_checksum;
-    use super::tr::Tr;
-    use super::*;
+    use std::cmp;
+    use std::collections::HashMap;
+    use std::str::FromStr;
+
     use bitcoin::blockdata::opcodes::all::{OP_CLTV, OP_CSV};
     use bitcoin::blockdata::script::Instruction;
     use bitcoin::blockdata::{opcodes, script};
@@ -839,13 +840,13 @@ mod tests {
         DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePub, DescriptorXKey,
     };
     use hex_script;
-    use std::cmp;
-    use std::collections::HashMap;
-    use std::str::FromStr;
-    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
-
     #[cfg(feature = "compiler")]
     use policy;
+    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+
+    use super::checksum::desc_checksum;
+    use super::tr::Tr;
+    use super::*;
 
     type StdDescriptor = Descriptor<PublicKey>;
     const TEST_PK: &'static str =

src/descriptor/pretaproot.rs

@@ -4,9 +4,9 @@ use std::{
 };
 
 use bitcoin::{self, Script};
+use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
 use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
-use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -240,7 +240,6 @@ 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,

src/descriptor/segwitv0.rs

@@ -19,7 +19,6 @@
 use std::{fmt, str::FromStr};
 
 use bitcoin::{self, Script};
-
 use expression::{self, FromTree};
 use miniscript::context::{ScriptContext, ScriptContextError};
 use policy::{semantic, Liftable};

src/descriptor/sh.rs

@@ -21,7 +21,6 @@
 use std::{fmt, str::FromStr};
 
 use bitcoin::{self, blockdata::script, Script};
-
 use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};

src/descriptor/sortedmulti.rs

@@ -19,7 +19,6 @@
 use std::{fmt, marker::PhantomData, str::FromStr};
 
 use bitcoin::blockdata::script;
-
 use expression;
 use miniscript::{
     self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
@@ -240,10 +239,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for SortedMultiVec<Pk,
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use bitcoin::secp256k1::PublicKey;
     use miniscript::context::Legacy;
 
+    use super::*;
+
     #[test]
     fn too_many_pubkeys() {
         // Arbitrary pubic key.

src/descriptor/tr.rs

@@ -1,11 +1,10 @@
 // Tapscript
 
-use policy::semantic::Policy;
-use policy::Liftable;
-use util::{varint_len, witness_size};
-use {DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
+use std::cmp::{self, max};
+use std::hash;
+use std::sync::{Arc, Mutex};
+use std::{fmt, str::FromStr};
 
-use super::checksum::{desc_checksum, verify_checksum};
 use bitcoin::blockdata::opcodes;
 use bitcoin::util::taproot::{
     LeafVersion, TaprootBuilder, TaprootBuilderError, TaprootSpendInfo, TAPROOT_CONTROL_BASE_SIZE,
@@ -15,13 +14,15 @@ use bitcoin::{self, secp256k1, Script};
 use errstr;
 use expression::{self, FromTree};
 use miniscript::Miniscript;
-use std::cmp::{self, max};
-use std::hash;
-use std::sync::{Arc, Mutex};
-use std::{fmt, str::FromStr};
+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 super::checksum::{desc_checksum, verify_checksum};
+
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should
 // be simple to integrate those here, but it is best to wait on core for the exact syntax.
@@ -748,9 +749,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use ForEachKey;
 
+    use super::*;
+
     #[test]
     fn test_for_each() {
         let desc = "tr(acc0, {

src/expression.rs

@@ -19,7 +19,6 @@ use std::str::FromStr;
 
 use errstr;
 use Error;
-
 use MAX_RECURSION_DEPTH;
 
 #[derive(Debug)]

src/interpreter/error.rs

@@ -12,10 +12,11 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
+use std::{error, fmt};
+
 use bitcoin::hashes::{hash160, hex::ToHex};
 use bitcoin::util::taproot;
 use bitcoin::{self, secp256k1};
-use std::{error, fmt};
 
 use super::BitcoinKey;
 

src/interpreter/inner.rs

@@ -16,12 +16,11 @@ use bitcoin;
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::hashes::{hash160, sha256, Hash};
 use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
-
+use miniscript::context::{NoChecks, ScriptContext};
 use {BareCtx, Legacy, Segwitv0, Tap};
+use {Miniscript, MiniscriptKey};
 
 use super::{stack, BitcoinKey, Error, Stack, TypedHash160};
-use miniscript::context::{NoChecks, ScriptContext};
-use {Miniscript, MiniscriptKey};
 
 /// Attempts to parse a slice as a Bitcoin public key, checking compressedness
 /// if asked to, but otherwise dropping it
@@ -399,12 +398,14 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::XOnlyPublicKey, Ctx>
 #[cfg(test)]
 mod tests {
 
-    use super::*;
+    use std::str::FromStr;
+
     use bitcoin::blockdata::script;
     use bitcoin::hashes::hex::FromHex;
     use bitcoin::hashes::{hash160, sha256, Hash};
     use bitcoin::{self, Script};
-    use std::str::FromStr;
+
+    use super::*;
 
     struct KeyTestData {
         pk_spk: bitcoin::Script,

src/interpreter/mod.rs

@@ -19,13 +19,13 @@
 //! assuming that the spent coin was descriptor controlled.
 //!
 
-use bitcoin::blockdata::witness::Witness;
-use bitcoin::util::{sighash, taproot};
 use std::borrow::Borrow;
 use std::fmt;
 use std::str::FromStr;
 
+use bitcoin::blockdata::witness::Witness;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
+use bitcoin::util::{sighash, taproot};
 use bitcoin::{self, secp256k1, TxOut};
 use miniscript::context::NoChecks;
 use miniscript::ScriptContext;
@@ -1030,8 +1030,6 @@ fn verify_sersig<'txin>(
 #[cfg(test)]
 mod tests {
 
-    use super::inner::ToNoChecks;
-    use super::*;
     use bitcoin;
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
     use bitcoin::secp256k1::{self, Secp256k1};
@@ -1040,6 +1038,9 @@ mod tests {
     use MiniscriptKey;
     use ToPublicKey;
 
+    use super::inner::ToNoChecks;
+    use super::*;
+
     fn setup_keys_sigs(
         n: usize,
     ) -> (

src/lib.rs

@@ -121,16 +121,14 @@ use std::{error, fmt, hash, str};
 
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, sha256, Hash};
-
+pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
 pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use interpreter::Interpreter;
 pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
 pub use miniscript::decode::Terminal;
 pub use miniscript::satisfy::{Preimage32, Satisfier};
 pub use miniscript::Miniscript;
 
-pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
-
 ///Public key trait which can be converted to Hash type
 pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
     /// Returns true if the pubkey is uncompressed. Defaults to `false`.

src/miniscript/analyzable.rs

@@ -17,10 +17,11 @@
 //! Tools for determining whether the guarantees offered by the library
 //! actually hold.
 
-use error;
-use miniscript::iter::PkPkh;
 use std::collections::HashSet;
 use std::fmt;
+
+use error;
+use miniscript::iter::PkPkh;
 use {Miniscript, MiniscriptKey, ScriptContext};
 /// Possible reasons Miniscript guarantees can fail
 /// We currently mark Miniscript as Non-Analyzable if