Format Rust code using rustfmt

kinode/src/net/tcp/utils.rs

@@ -3,7 +3,9 @@ use crate::net::{
     types::{HandshakePayload, IdentityExt, Peers},
     utils::{print_debug, print_loud, IDLE_TIMEOUT, MESSAGE_MAX_SIZE},
 };
-use lib::types::core::{check_process_id_kimap_safe, KernelMessage, MessageSender, NodeId, PrintSender};
+use lib::types::core::{
+    check_process_id_kimap_safe, KernelMessage, MessageSender, NodeId, PrintSender,
+};
 use {
     tokio::io::{AsyncReadExt, AsyncWriteExt},
     tokio::net::{tcp::OwnedReadHalf, tcp::OwnedWriteHalf, TcpStream},
@@ -67,7 +69,10 @@ pub async fn maintain_connection(
                     if check_process_id_kimap_safe(&km.source.process).is_err() {
                         print_loud(
                             &read_print_tx,
-                            &format!("net: got message from non-Kimap-safe process: {}", km.source),
+                            &format!(
+                                "net: got message from non-Kimap-safe process: {}",
+                                km.source
+                            ),
                         )
                         .await;
                         break;

kinode/src/net/ws/utils.rs

@@ -88,7 +88,10 @@ pub async fn maintain_connection(
                     if check_process_id_kimap_safe(&km.source.process).is_err() {
                         print_loud(
                             &read_print_tx,
-                            &format!("net: got message from non-Kimap-safe process: {}", km.source),
+                            &format!(
+                                "net: got message from non-Kimap-safe process: {}",
+                                km.source
+                            ),
                         )
                         .await;
                         break;

kinode/src/state.rs

@@ -1,8 +1,9 @@
 use lib::types::core::{
-    Address, Capability, check_process_id_kimap_safe, Erc721Metadata, KernelMessage, LazyLoadBlob, Message, MessageReceiver,
+    check_process_id_kimap_safe, Address, Capability, Erc721Metadata, KernelMessage, LazyLoadBlob,
-    MessageSender, NetworkErrorSender, OnExit, PackageManifestEntry, PersistedProcess, PrintSender,
+    Message, MessageReceiver, MessageSender, NetworkErrorSender, OnExit, PackageManifestEntry,
-    Printout, ProcessId, ProcessMap, Request, Response, ReverseCapIndex, StateAction, StateError,
+    PersistedProcess, PrintSender, Printout, ProcessId, ProcessMap, Request, Response,
-    StateResponse, KERNEL_PROCESS_ID, STATE_PROCESS_ID, VFS_PROCESS_ID,
+    ReverseCapIndex, StateAction, StateError, StateResponse, KERNEL_PROCESS_ID, STATE_PROCESS_ID,
+    VFS_PROCESS_ID,
 };
 use ring::signature;
 use rocksdb::{checkpoint::Checkpoint, Options, DB};

lib/src/core.rs

@@ -58,13 +58,19 @@ pub fn is_kimap_safe_no_dots(input: &str) -> bool {
 
 pub fn check_process_id_kimap_safe(p: &ProcessId) -> Result<(), AddressParseError> {
     if !is_kimap_safe_no_dots(&p.process_name) {
-        return Err(AddressParseError::ProcessNameNotKimapSafe(p.process_name.clone()));
+        return Err(AddressParseError::ProcessNameNotKimapSafe(
+            p.process_name.clone(),
+        ));
     }
     if !is_kimap_safe_no_dots(&p.package_name) {
-        return Err(AddressParseError::PackageNameNotKimapSafe(p.package_name.clone()));
+        return Err(AddressParseError::PackageNameNotKimapSafe(
+            p.package_name.clone(),
+        ));
     }
     if !is_kimap_safe(&p.publisher_node) {
-        return Err(AddressParseError::PublisherNodeNotKimapSafe(p.publisher_node.clone()));
+        return Err(AddressParseError::PublisherNodeNotKimapSafe(
+            p.publisher_node.clone(),
+        ));
     }
     Ok(())
 }
@@ -105,11 +111,7 @@ impl<'a> Deserialize<'a> for ProcessId {
 /// are defined here.
 impl ProcessId {
     /// generates a random u64 number if process_name is not declared
-    pub fn new(
+    pub fn new(process_name: Option<&str>, package_name: &str, publisher_node: &str) -> Self {
-        process_name: Option<&str>,
-        package_name: &str,
-        publisher_node: &str,
-    ) -> Self {
         let process_name = process_name
             .unwrap_or(&rand::random::<u64>().to_string())
             .to_string();
@@ -191,7 +193,11 @@ impl std::str::FromStr for ProcessId {
         if publisher_node.is_empty() {
             return Err(AddressParseError::MissingField);
         }
-        Ok(ProcessId::new(Some(process_name), package_name, publisher_node))
+        Ok(ProcessId::new(
+            Some(process_name),
+            package_name,
+            publisher_node,
+        ))
     }
 }
 
@@ -394,7 +400,10 @@ impl std::str::FromStr for Address {
         if publisher_node.is_empty() {
             return Err(AddressParseError::MissingField);
         }
-        Ok(Address::new(node, (process_name, package_name, publisher_node)))
+        Ok(Address::new(
+            node,
+            (process_name, package_name, publisher_node),
+        ))
     }
 }