From b87e1f56764db61beae80970d3a7a52fee53cfa7 Mon Sep 17 00:00:00 2001
From: Sylvestre Ledru <sylvestre@debian.org>
Date: Thu, 5 Oct 2023 09:31:43 +0200
Subject: [PATCH 1/2] chown: move uid & gid detections into their own functions

---
 src/uu/chown/src/chown.rs | 95 ++++++++++++++++++++-------------------
 1 file changed, 49 insertions(+), 46 deletions(-)

diff --git a/src/uu/chown/src/chown.rs b/src/uu/chown/src/chown.rs
index 8e97d5652..ea25050bb 100644
--- a/src/uu/chown/src/chown.rs
+++ b/src/uu/chown/src/chown.rs
@@ -195,6 +195,53 @@ pub fn uu_app() -> Command {
         )
 }
 
+/// Parses the user string to extract the UID.
+fn parse_uid(user: &str, spec: &str, sep: char) -> UResult<Option<u32>> {
+    if user.is_empty() {
+        return Ok(None);
+    }
+    match Passwd::locate(user) {
+        Ok(u) => Ok(Some(u.uid)), // We have been able to get the uid
+        Err(_) => {
+            // we have NOT been able to find the uid
+            // but we could be in the case where we have user.group
+            if spec.contains('.') && !spec.contains(':') && sep == ':' {
+                // but the input contains a '.' but not a ':'
+                // we might have something like username.groupname
+                // So, try to parse it this way
+                return parse_spec(spec, '.').map(|(uid, _)| uid);
+            } else {
+                // It's possible that the `user` string contains a
+                // numeric user ID, in which case, we respect that.
+                match user.parse() {
+                    Ok(uid) => Ok(Some(uid)),
+                    Err(_) => Err(USimpleError::new(
+                        1,
+                        format!("invalid user: {}", spec.quote()),
+                    )),
+                }
+            }
+        }
+    }
+}
+
+/// Parses the group string to extract the GID.
+fn parse_gid(group: &str, spec: &str) -> UResult<Option<u32>> {
+    if group.is_empty() {
+        return Ok(None);
+    }
+    match Group::locate(group) {
+        Ok(g) => Ok(Some(g.gid)),
+        Err(_) => match group.parse() {
+            Ok(gid) => Ok(Some(gid)),
+            Err(_) => Err(USimpleError::new(
+                1,
+                format!("invalid group: {}", spec.quote()),
+            )),
+        },
+    }
+}
+
 /// Parse the owner/group specifier string into a user ID and a group ID.
 ///
 /// The `spec` can be of the form:
@@ -213,52 +260,8 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
     let user = args.next().unwrap_or("");
     let group = args.next().unwrap_or("");
 
-    let uid = if user.is_empty() {
-        None
-    } else {
-        Some(match Passwd::locate(user) {
-            Ok(u) => u.uid, // We have been able to get the uid
-            Err(_) =>
-            // we have NOT been able to find the uid
-            // but we could be in the case where we have user.group
-            {
-                if spec.contains('.') && !spec.contains(':') && sep == ':' {
-                    // but the input contains a '.' but not a ':'
-                    // we might have something like username.groupname
-                    // So, try to parse it this way
-                    return parse_spec(spec, '.');
-                } else {
-                    // It's possible that the `user` string contains a
-                    // numeric user ID, in which case, we respect that.
-                    match user.parse() {
-                        Ok(uid) => uid,
-                        Err(_) => {
-                            return Err(USimpleError::new(
-                                1,
-                                format!("invalid user: {}", spec.quote()),
-                            ))
-                        }
-                    }
-                }
-            }
-        })
-    };
-    let gid = if group.is_empty() {
-        None
-    } else {
-        Some(match Group::locate(group) {
-            Ok(g) => g.gid,
-            Err(_) => match group.parse() {
-                Ok(gid) => gid,
-                Err(_) => {
-                    return Err(USimpleError::new(
-                        1,
-                        format!("invalid group: {}", spec.quote()),
-                    ));
-                }
-            },
-        })
-    };
+    let uid = parse_uid(user, spec, sep)?;
+    let gid = parse_gid(group, spec)?;
 
     if user.chars().next().map(char::is_numeric).unwrap_or(false)
         && group.is_empty()

From 4760b1f340dfe30f23fdc8676211c7ae48b963da Mon Sep 17 00:00:00 2001
From: Daniel Hofstetter <daniel.hofstetter@42dh.com>
Date: Fri, 6 Oct 2023 07:49:36 +0200
Subject: [PATCH 2/2] chown: remove unnecessary return

---
 src/uu/chown/src/chown.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/uu/chown/src/chown.rs b/src/uu/chown/src/chown.rs
index ea25050bb..0e9b8b242 100644
--- a/src/uu/chown/src/chown.rs
+++ b/src/uu/chown/src/chown.rs
@@ -209,7 +209,7 @@ fn parse_uid(user: &str, spec: &str, sep: char) -> UResult<Option<u32>> {
                 // but the input contains a '.' but not a ':'
                 // we might have something like username.groupname
                 // So, try to parse it this way
-                return parse_spec(spec, '.').map(|(uid, _)| uid);
+                parse_spec(spec, '.').map(|(uid, _)| uid)
             } else {
                 // It's possible that the `user` string contains a
                 // numeric user ID, in which case, we respect that.