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).

Author: tcharding

examples/htlc.rs

@@ -14,11 +14,12 @@
 
 //! Example: Create an HTLC with miniscript using the policy compiler
 
+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

@@ -14,9 +14,10 @@
 
 //! Example: Parsing a descriptor from a string.
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
 use std::str::FromStr;
 
+use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+
 fn main() {
     let desc = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(
         "wsh(c:pk_k(020202020202020202020202020202020202020202020202020202020202020202))",

examples/sign_multisig.rs

@@ -14,11 +14,12 @@
 
 //! Example: Signing a 2-of-3 multisignature.
 
+use std::collections::HashMap;
+use std::str::FromStr;
+
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::secp256k1;
 use miniscript::DescriptorTrait;
-use std::collections::HashMap;
-use std::str::FromStr;
 
 fn main() {
     let mut tx = spending_transaction();

examples/verify_tx.rs

@@ -14,11 +14,12 @@
 
 //! Example: Verifying a signed transaction.
 
+use std::str::FromStr;
+
 use bitcoin::consensus::Decodable;
 use bitcoin::secp256k1::{self, Secp256k1};
 use bitcoin::util::sighash;
 use miniscript::interpreter::KeySigPair;
-use std::str::FromStr;
 
 fn main() {
     //

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

@@ -22,6 +22,10 @@ use std::{fmt, str::FromStr};
 
 use bitcoin::{self, blockdata::script, Script};
 
+use super::{
+    checksum::{desc_checksum, verify_checksum},
+    DescriptorTrait,
+};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
@@ -31,11 +35,6 @@ use crate::{
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
-};
-
 /// Create a Bare Descriptor. That is descriptor that is
 /// not wrapped in sh or wsh. This covers the Pk descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]

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

@@ -723,11 +723,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

@@ -857,26 +857,27 @@ serde_string_impl_pk!(Descriptor, "a script descriptor");
 
 #[cfg(test)]
 mod tests {
-    use super::checksum::desc_checksum;
-    use super::tr::Tr;
-    use super::*;
-    use crate::descriptor::key::Wildcard;
-    use crate::descriptor::{DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey, SinglePub};
-    use crate::hex_script;
-    use crate::{Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    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};
     use bitcoin::hashes::hex::{FromHex, ToHex};
     use bitcoin::hashes::{hash160, sha256};
     use bitcoin::util::bip32;
     use bitcoin::{self, secp256k1, EcdsaSighashType, PublicKey};
-    use std::cmp;
-    use std::collections::HashMap;
-    use std::str::FromStr;
 
+    use super::checksum::desc_checksum;
+    use super::tr::Tr;
+    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};
 
     type StdDescriptor = Descriptor<PublicKey>;
     const TEST_PK: &'static str =

src/descriptor/pretaproot.rs

@@ -241,13 +241,12 @@ serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor");
 pub(crate) mod traits {
     use bitcoin::Script;
 
+    use super::PreTaprootDescriptor;
     use crate::{
         descriptor::{Pkh, Sh, Wpkh, Wsh},
         DescriptorTrait, MiniscriptKey, ToPublicKey,
     };
 
-    use super::PreTaprootDescriptor;
-
     /// A general trait for Pre taproot bitcoin descriptor.
     /// Similar to [`DescriptorTrait`], but `explicit_script` and `script_code` methods cannot fail
     pub trait PreTaprootDescriptorTrait<Pk: MiniscriptKey>: DescriptorTrait<Pk> {

src/descriptor/segwitv0.rs

@@ -20,6 +20,10 @@ use std::{fmt, str::FromStr};
 
 use bitcoin::{self, Script};
 
+use super::{
+    checksum::{desc_checksum, verify_checksum},
+    DescriptorTrait, SortedMultiVec,
+};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::{ScriptContext, ScriptContextError};
 use crate::policy::{semantic, Liftable};
@@ -28,11 +32,6 @@ use crate::{
     Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey,
     TranslatePk,
 };
-
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
-};
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct Wsh<Pk: MiniscriptKey> {

src/descriptor/sh.rs

@@ -22,6 +22,10 @@ use std::{fmt, str::FromStr};
 
 use bitcoin::{self, blockdata::script, Script};
 
+use super::{
+    checksum::{desc_checksum, verify_checksum},
+    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
+};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
@@ -32,11 +36,6 @@ use crate::{
     ToPublicKey, TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
-};
-
 /// A Legacy p2sh Descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct Sh<Pk: MiniscriptKey> {

src/descriptor/sortedmulti.rs

@@ -242,10 +242,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,26 +1,27 @@
 // Tapscript
 
-use crate::policy::semantic::Policy;
-use crate::policy::Liftable;
-use crate::util::{varint_len, witness_size};
-use crate::{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 crate::errstr;
-use crate::expression::{self, FromTree};
-use crate::miniscript::Miniscript;
-use crate::Tap;
-use crate::{Error, MiniscriptKey};
 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 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 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};
 
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should

src/expression.rs

@@ -19,7 +19,6 @@ use std::str::FromStr;
 
 use crate::errstr;
 use crate::Error;
-
 use crate::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

@@ -17,10 +17,9 @@ use bitcoin::blockdata::witness::Witness;
 use bitcoin::hashes::{hash160, sha256, Hash};
 use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 
-use crate::{BareCtx, Legacy, Segwitv0, Tap};
-
 use super::{stack, BitcoinKey, Error, Stack, TypedHash160};
 use crate::miniscript::context::{NoChecks, ScriptContext};
+use crate::{BareCtx, Legacy, Segwitv0, Tap};
 use crate::{Miniscript, MiniscriptKey};
 
 /// Attempts to parse a slice as a Bitcoin public key, checking compressedness
@@ -401,12 +400,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,29 +19,29 @@
 //! 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 crate::miniscript::context::NoChecks;
 use crate::miniscript::ScriptContext;
 use crate::Miniscript;
 use crate::Terminal;
 use crate::{Descriptor, ToPublicKey};
-use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
-use bitcoin::{self, secp256k1, TxOut};
 
 mod error;
 mod inner;
 mod stack;
 
-use crate::MiniscriptKey;
-
 pub use self::error::Error;
 use self::error::PkEvalErrInner;
 use self::stack::Stack;
+use crate::MiniscriptKey;
 
 /// An iterable Miniscript-structured representation of the spending of a coin
 pub struct Interpreter<'txin> {
@@ -1030,15 +1030,16 @@ fn verify_sersig<'txin>(
 #[cfg(test)]
 mod tests {
 
+    use bitcoin;
+    use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+    use bitcoin::secp256k1::{self, Secp256k1};
+
     use super::inner::ToNoChecks;
     use super::*;
     use crate::miniscript::context::NoChecks;
     use crate::Miniscript;
     use crate::MiniscriptKey;
     use crate::ToPublicKey;
-    use bitcoin;
-    use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-    use bitcoin::secp256k1::{self, Secp256k1};
 
     fn setup_keys_sigs(
         n: usize,

src/lib.rs

@@ -119,15 +119,14 @@ use std::{error, fmt, hash, str};
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, sha256, Hash};
 
+pub use crate::descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
 pub use crate::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use crate::interpreter::Interpreter;
 pub use crate::miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
 pub use crate::miniscript::decode::Terminal;
 pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
 pub use crate::miniscript::Miniscript;
 
-pub use crate::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`.