More wide rust formatting rules

Author: dr-orlovsky

.rustfmt.toml

@@ -1,4 +1,16 @@
-max_width = 80
+max_width = 100
+format_code_in_doc_comments = true
+fn_single_line = true
+format_macro_matchers = true
+format_strings = true
+merge_derives = false
+imports_granularity = "Module"
+overflow_delimited_expr = true
+group_imports = "StdExternalCrate"
+use_field_init_shorthand = true
+use_try_shorthand = true
 wrap_comments = true
+comment_width = 100
+use_small_heuristics = "Max"
+unstable_features = true
 license_template_path = "license_header.txt"
-format_code_in_doc_comments = true

build.rs

@@ -18,7 +18,8 @@ extern crate amplify;
 extern crate clap;
 
 use clap::IntoApp;
-use clap_generate::{generate_to, generators::*};
+use clap_generate::generate_to;
+use clap_generate::generators::*;
 
 pub mod opts {
     include!("src/opts.rs");

src/bin/lnp-cli.rs

@@ -36,11 +36,8 @@ fn main() {
     debug!("MSG RPC socket {}", &config.msg_endpoint);
     debug!("CTL RPC socket {}", &config.ctl_endpoint);
 
-    let mut client = Client::with(config, opts.shared.chain)
-        .expect("Error initializing client");
+    let mut client = Client::with(config, opts.shared.chain).expect("Error initializing client");
 
     trace!("Executing command: {:?}", opts.command);
-    opts.command
-        .exec(&mut client)
-        .unwrap_or_else(|err| eprintln!("{}", err.err()));
+    opts.command.exec(&mut client).unwrap_or_else(|err| eprintln!("{}", err.err()));
 }

src/bin/lnpd.rs

@@ -71,69 +71,45 @@ fn main() -> Result<(), Error> {
 }
 
 fn init(config: &Config) -> Result<(), Error> {
+    use std::fs;
+    use std::process::exit;
+    use std::str::FromStr;
+
     use bitcoin::secp256k1::Secp256k1;
     use bitcoin::util::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey};
-    use bitcoin_hd::{
-        SegmentIndexes, TerminalStep, TrackingAccount, UnhardenedIndex,
-    };
+    use bitcoin_hd::{SegmentIndexes, TerminalStep, TrackingAccount, UnhardenedIndex};
     use lnp_node::lnpd::funding_wallet::{FundingWallet, WalletData};
     use lnp_node::opts::{LNP_NODE_FUNDING_WALLET, LNP_NODE_MASTER_WALLET};
     use miniscript::descriptor::{Descriptor, Wpkh};
     use psbt::sign::MemorySigningAccount;
-    use std::fs;
-    use std::process::exit;
-    use std::str::FromStr;
 
     let secp = Secp256k1::new();
 
     println!("\n{}", "Initializing node data".progress());
 
     if !config.data_dir.exists() {
-        println!(
-            "Data directory '{}' ... {}",
-            config.data_dir.display(),
-            "creating".action()
-        );
+        println!("Data directory '{}' ... {}", config.data_dir.display(), "creating".action());
         fs::create_dir_all(&config.data_dir)?;
     } else {
-        println!(
-            "Data directory '{}' ... {}",
-            config.data_dir.display(),
-            "found".progress()
-        );
+        println!("Data directory '{}' ... {}", config.data_dir.display(), "found".progress());
     }
 
     let mut wallet_path = config.data_dir.clone();
     wallet_path.push(LNP_NODE_MASTER_WALLET);
     let signing_account = if !wallet_path.exists() {
-        println!(
-            "Signing account '{}' ... {}",
-            LNP_NODE_MASTER_WALLET,
-            "creating".action()
-        );
-        let xpriv = rpassword::read_password_from_tty(Some(
-            "Please enter your master xpriv: ",
-        ))?;
+        println!("Signing account '{}' ... {}", LNP_NODE_MASTER_WALLET, "creating".action());
+        let xpriv = rpassword::read_password_from_tty(Some("Please enter your master xpriv: "))?;
         let xpriv = ExtendedPrivKey::from_str(&xpriv)?;
-        let derivation = DerivationPath::from_str("m/10046h")
-            .expect("hardcoded derivation path");
+        let derivation = DerivationPath::from_str("m/10046h").expect("hardcoded derivation path");
         let xpriv_account = xpriv.derive_priv(&secp, &derivation)?;
         let fingerprint = xpriv.identifier(&secp);
-        let signing_account = MemorySigningAccount::with(
-            &secp,
-            fingerprint,
-            derivation,
-            xpriv_account,
-        );
+        let signing_account =
+            MemorySigningAccount::with(&secp, fingerprint, derivation, xpriv_account);
         let file = fs::File::create(wallet_path)?;
         signing_account.write(file)?;
         signing_account
     } else {
-        println!(
-            "Signing account '{}' ... {}",
-            LNP_NODE_MASTER_WALLET,
-            "found".progress()
-        );
+        println!("Signing account '{}' ... {}", LNP_NODE_MASTER_WALLET, "found".progress());
         MemorySigningAccount::read(&secp, fs::File::open(wallet_path)?)?
     };
     println!(
@@ -149,11 +125,7 @@ fn init(config: &Config) -> Result<(), Error> {
     let mut wallet_path = config.data_dir.clone();
     wallet_path.push(LNP_NODE_FUNDING_WALLET);
     let funding_wallet = if !wallet_path.exists() {
-        println!(
-            "Funding wallet '{}' ... {}",
-            LNP_NODE_FUNDING_WALLET,
-            "creating".action()
-        );
+        println!("Funding wallet '{}' ... {}", LNP_NODE_FUNDING_WALLET, "creating".action());
         let account_path = &[10046_u16, 0, 2][..];
         let node_xpriv = signing_account.account_xpriv();
         let account_xpriv = node_xpriv.derive_priv(
@@ -179,24 +151,12 @@ fn init(config: &Config) -> Result<(), Error> {
             last_change_index: UnhardenedIndex::zero(),
             last_rgb_index: Default::default(),
         };
-        FundingWallet::new(
-            &config.chain,
-            wallet_path,
-            wallet_data,
-            &config.electrum_url,
-        )?
+        FundingWallet::new(&config.chain, wallet_path, wallet_data, &config.electrum_url)?
     } else {
-        println!(
-            "Funding wallet '{}' ... {}",
-            LNP_NODE_FUNDING_WALLET,
-            "found".progress()
-        );
+        println!("Funding wallet '{}' ... {}", LNP_NODE_FUNDING_WALLET, "found".progress());
         FundingWallet::with(&config.chain, wallet_path, &config.electrum_url)?
     };
-    println!(
-        "Funding wallet: {}",
-        funding_wallet.wallet_data().descriptor.promo()
-    );
+    println!("Funding wallet: {}", funding_wallet.wallet_data().descriptor.promo());
 
     println!("{}", "Node initialization complete\n".ended());
 

src/bin/peerd.rs

@@ -59,11 +59,10 @@
 //! The overall program logic thus is the following:
 //!
 //! In the process starting from `main()`:
-//! - Parse cli arguments into a config. There is no config file, since the
-//!   daemon can be started only from another control process (`lnpd`) or by
-//!   forking itself.
-//! - If `--listen` argument is present, start a listening version as described
-//!   above and open TCP port in listening mode; wait for incoming connections
+//! - Parse cli arguments into a config. There is no config file, since the daemon can be started
+//!   only from another control process (`lnpd`) or by forking itself.
+//! - If `--listen` argument is present, start a listening version as described above and open TCP
+//!   port in listening mode; wait for incoming connections
 //! - If `--connect` argument is present, connect to the remote TCP peer
 //!
 //! In forked/spawned version:
@@ -73,8 +72,7 @@
 //! launched from the control process:
 //! - Split TCP socket and related transcoders into reading and writing parts
 //! - Create bridge ZMQ PAIR socket
-//! - Put both TCP socket reading ZMQ bridge write PAIR parts into a thread
-//!   ("bridge")
+//! - Put both TCP socket reading ZMQ bridge write PAIR parts into a thread ("bridge")
 //! - Open control interface socket
 //! - Create run loop in the main thread for polling three ZMQ sockets:
 //!   * control interface
@@ -93,21 +91,18 @@ extern crate log;
 #[macro_use]
 extern crate amplify;
 
-use clap::Parser;
-use internet2::addr::InetSocketAddr;
-use nix::unistd::{fork, ForkResult};
 use std::convert::TryFrom;
-use std::net::TcpListener;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener};
 use std::time::Duration;
 
 use bitcoin::secp256k1::PublicKey;
-use internet2::{
-    session, FramingProtocol, NodeAddr, RemoteNodeAddr, RemoteSocketAddr,
-};
+use clap::Parser;
+use internet2::addr::InetSocketAddr;
+use internet2::{session, FramingProtocol, NodeAddr, RemoteNodeAddr, RemoteSocketAddr};
 use lnp_node::peerd::{self, Opts};
 use lnp_node::{Config, LogStyle};
 use microservices::peer::PeerConnection;
+use nix::unistd::{fork, ForkResult};
 
 /*
 mod internal {
@@ -142,21 +137,15 @@ impl From<Opts> for PeerSocket {
             Self::Connect(peer_addr)
         } else if let Some(bind_addr) = opts.listen {
             Self::Listen(match opts.overlay {
-                FramingProtocol::FramedRaw => {
-                    RemoteSocketAddr::Ftcp(InetSocketAddr {
-                        address: bind_addr
-                            .unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED))
-                            .into(),
-                        port: opts.port,
-                    })
-                }
+                FramingProtocol::FramedRaw => RemoteSocketAddr::Ftcp(InetSocketAddr {
+                    address: bind_addr.unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED)).into(),
+                    port: opts.port,
+                }),
                 // TODO: (v2) implement overlay protocols
                 _ => unimplemented!(),
             })
         } else {
-            unreachable!(
-                "Either `connect` or `listen` must be present due to Clap configuration"
-            )
+            unreachable!("Either `connect` or `listen` must be present due to Clap configuration")
         }
     }
 }
@@ -207,29 +196,24 @@ fn main() {
 
             debug!("Binding TCP socket {}", inet_addr);
             let listener = TcpListener::bind(
-                SocketAddr::try_from(inet_addr)
-                    .expect("Tor is not yet supported"),
+                SocketAddr::try_from(inet_addr).expect("Tor is not yet supported"),
             )
             .expect("Unable to bind to Lightning network peer socket");
 
             debug!("Running TCP listener event loop");
             loop {
                 debug!("Awaiting for incoming connections...");
-                let (stream, remote_socket_addr) = listener
-                    .accept()
-                    .expect("Error accepting incpming peer connection");
+                let (stream, remote_socket_addr) =
+                    listener.accept().expect("Error accepting incpming peer connection");
                 debug!("New connection from {}", remote_socket_addr);
 
                 remote_socket = remote_socket_addr.into();
 
                 // TODO: Support multithread mode
                 debug!("Forking child process");
-                if let ForkResult::Child =
-                    unsafe { fork().expect("Unable to fork child process") }
+                if let ForkResult::Child = unsafe { fork().expect("Unable to fork child process") }
                 {
-                    trace!(
-                        "Child forked; returning into main listener event loop"
-                    );
+                    trace!("Child forked; returning into main listener event loop");
                     continue;
                 }
 
@@ -238,11 +222,8 @@ fn main() {
                     .expect("Unable to set up timeout for TCP connection");
 
                 debug!("Establishing session with the remote");
-                let session =
-                    session::Raw::with_ftcp_unencrypted(stream, inet_addr)
-                        .expect(
-                            "Unable to establish session with the remote peer",
-                        );
+                let session = session::Raw::with_ftcp_unencrypted(stream, inet_addr)
+                    .expect("Unable to establish session with the remote peer");
 
                 debug!("Session successfully established");
                 break PeerConnection::with(session);
@@ -264,17 +245,8 @@ fn main() {
     };
 
     debug!("Starting runtime ...");
-    peerd::run(
-        config,
-        connection,
-        id,
-        local_id,
-        remote_id,
-        local_socket,
-        remote_socket,
-        connect,
-    )
-    .expect("Error running peerd runtime");
+    peerd::run(config, connection, id, local_id, remote_id, local_socket, remote_socket, connect)
+        .expect("Error running peerd runtime");
 
     unreachable!()
 }

src/channeld/opts.rs

@@ -18,7 +18,6 @@ use internet2::PartialNodeAddr;
 use lnp::p2p::legacy::ChannelId;
 
 use crate::opts::FUNGIBLED_RPC_ENDPOINT;
-
 use crate::peerd::KeyOpts;
 
 /// Lightning peer network channel daemon; part of LNP Node
@@ -71,8 +70,7 @@ impl Opts {
 impl RgbOpts {
     pub fn process(&mut self, shared: &crate::opts::Opts) {
         match &mut self.rgb20_socket {
-            PartialNodeAddr::ZmqIpc(path, ..)
-            | PartialNodeAddr::Posix(path) => {
+            PartialNodeAddr::ZmqIpc(path, ..) | PartialNodeAddr::Posix(path) => {
                 shared.process_dir(path);
             }
             _ => {}