From b4b0a7dbba287df50ae8c7ea781adffe1fcf4dba Mon Sep 17 00:00:00 2001
From: Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
Date: Mon, 15 Jul 2024 18:27:35 +0200
Subject: [PATCH] jid: Simplify from_parts() a bit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

By defining the variables in the parent scope, we can avoid one level of
indentation for the tuple, which makes things more readable.

Additionally, we don’t need to call .to_str() on the passed objects,
they automatically Deref to &str for the format!() call.
---
 jid/src/lib.rs | 42 ++++++++++++++++++------------------------
 1 file changed, 18 insertions(+), 24 deletions(-)

diff --git a/jid/src/lib.rs b/jid/src/lib.rs
index 770044cf..d9927bd0 100644
--- a/jid/src/lib.rs
+++ b/jid/src/lib.rs
@@ -687,25 +687,18 @@ impl FullJid {
         domain: &DomainRef,
         resource: &ResourceRef,
     ) -> FullJid {
-        let (at, slash, normalized) = if let Some(node) = node {
+        let (at, slash, normalized);
+
+        if let Some(node) = node {
             // Parts are never empty so len > 0 for NonZeroU16::new is always Some
-            (
-                NonZeroU16::new(node.len() as u16),
-                NonZeroU16::new((node.len() + 1 + domain.len()) as u16),
-                format!(
-                    "{}@{}/{}",
-                    node.as_str(),
-                    domain.as_str(),
-                    resource.as_str()
-                ),
-            )
+            at = NonZeroU16::new(node.len() as u16);
+            slash = NonZeroU16::new((node.len() + 1 + domain.len()) as u16);
+            normalized = format!("{node}@{domain}/{resource}");
         } else {
-            (
-                None,
-                NonZeroU16::new(domain.len() as u16),
-                format!("{}/{}", domain.as_str(), resource.as_str()),
-            )
-        };
+            at = None;
+            slash = NonZeroU16::new(domain.len() as u16);
+            normalized = format!("{domain}/{resource}");
+        }
 
         let inner = Jid {
             normalized,
@@ -778,15 +771,16 @@ impl BareJid {
     /// allocation if `node` is known to be `None` and `domain` is owned, you
     /// can use `domain.into()`.
     pub fn from_parts(node: Option<&NodeRef>, domain: &DomainRef) -> Self {
-        let (at, normalized) = if let Some(node) = node {
+        let (at, normalized);
+
+        if let Some(node) = node {
             // Parts are never empty so len > 0 for NonZeroU16::new is always Some
-            (
-                NonZeroU16::new(node.len() as u16),
-                format!("{}@{}", node.as_str(), domain.as_str()),
-            )
+            at = NonZeroU16::new(node.len() as u16);
+            normalized = format!("{node}@{domain}");
         } else {
-            (None, domain.to_string())
-        };
+            at = None;
+            normalized = domain.to_string();
+        }
 
         let inner = Jid {
             normalized,