diff --git a/src/uu/uname/src/uname.rs b/src/uu/uname/src/uname.rs
index e6d5c3a0a32..4a7c3f460c6 100644
--- a/src/uu/uname/src/uname.rs
+++ b/src/uu/uname/src/uname.rs
@@ -27,80 +27,119 @@ pub mod options {
     pub static OS: &str = "operating-system";
 }
 
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
-
-    let uname = PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
-
-    let mut output = String::new();
-
-    let all = matches.get_flag(options::ALL);
-    let kernel_name = matches.get_flag(options::KERNEL_NAME);
-    let nodename = matches.get_flag(options::NODENAME);
-    let kernel_release = matches.get_flag(options::KERNEL_RELEASE);
-    let kernel_version = matches.get_flag(options::KERNEL_VERSION);
-    let machine = matches.get_flag(options::MACHINE);
-    let processor = matches.get_flag(options::PROCESSOR);
-    let hardware_platform = matches.get_flag(options::HARDWARE_PLATFORM);
-    let os = matches.get_flag(options::OS);
-
-    let none = !(all
-        || kernel_name
-        || nodename
-        || kernel_release
-        || kernel_version
-        || machine
-        || os
-        || processor
-        || hardware_platform);
-
-    if kernel_name || all || none {
-        output.push_str(&uname.sysname().to_string_lossy());
-        output.push(' ');
-    }
-
-    if nodename || all {
-        output.push_str(&uname.nodename().to_string_lossy());
-        output.push(' ');
-    }
-
-    if kernel_release || all {
-        output.push_str(&uname.release().to_string_lossy());
-        output.push(' ');
-    }
-
-    if kernel_version || all {
-        output.push_str(&uname.version().to_string_lossy());
-        output.push(' ');
-    }
-
-    if machine || all {
-        output.push_str(&uname.machine().to_string_lossy());
-        output.push(' ');
-    }
+pub struct UNameOutput {
+    pub kernel_name: Option<String>,
+    pub nodename: Option<String>,
+    pub kernel_release: Option<String>,
+    pub kernel_version: Option<String>,
+    pub machine: Option<String>,
+    pub os: Option<String>,
+    pub processor: Option<String>,
+    pub hardware_platform: Option<String>,
+}
 
-    if os || all {
-        output.push_str(&uname.osname().to_string_lossy());
-        output.push(' ');
+impl UNameOutput {
+    fn display(&self) -> String {
+        let mut output = String::new();
+        for name in [
+            self.kernel_name.as_ref(),
+            self.nodename.as_ref(),
+            self.kernel_release.as_ref(),
+            self.kernel_version.as_ref(),
+            self.machine.as_ref(),
+            self.os.as_ref(),
+            self.processor.as_ref(),
+            self.hardware_platform.as_ref(),
+        ]
+        .into_iter()
+        .flatten()
+        {
+            output.push_str(name);
+            output.push(' ');
+        }
+        output
     }
 
-    // This option is unsupported on modern Linux systems
-    // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
-    if processor {
-        output.push_str("unknown");
-        output.push(' ');
+    pub fn new(opts: &Options) -> UResult<Self> {
+        let uname =
+            PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+        let none = !(opts.all
+            || opts.kernel_name
+            || opts.nodename
+            || opts.kernel_release
+            || opts.kernel_version
+            || opts.machine
+            || opts.os
+            || opts.processor
+            || opts.hardware_platform);
+
+        let kernel_name = (opts.kernel_name || opts.all || none)
+            .then(|| uname.sysname().to_string_lossy().to_string());
+
+        let nodename =
+            (opts.nodename || opts.all).then(|| uname.nodename().to_string_lossy().to_string());
+
+        let kernel_release = (opts.kernel_release || opts.all)
+            .then(|| uname.release().to_string_lossy().to_string());
+
+        let kernel_version = (opts.kernel_version || opts.all)
+            .then(|| uname.version().to_string_lossy().to_string());
+
+        let machine =
+            (opts.machine || opts.all).then(|| uname.machine().to_string_lossy().to_string());
+
+        let os = (opts.os || opts.all).then(|| uname.osname().to_string_lossy().to_string());
+
+        // This option is unsupported on modern Linux systems
+        // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
+        let processor = opts.processor.then(|| "unknown".to_string());
+
+        // This option is unsupported on modern Linux systems
+        // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
+        let hardware_platform = opts.hardware_platform.then(|| "unknown".to_string());
+
+        Ok(Self {
+            kernel_name,
+            nodename,
+            kernel_release,
+            kernel_version,
+            machine,
+            os,
+            processor,
+            hardware_platform,
+        })
     }
+}
 
-    // This option is unsupported on modern Linux systems
-    // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
-    if hardware_platform {
-        output.push_str("unknown");
-        output.push(' ');
-    }
+pub struct Options {
+    pub all: bool,
+    pub kernel_name: bool,
+    pub nodename: bool,
+    pub kernel_version: bool,
+    pub kernel_release: bool,
+    pub machine: bool,
+    pub processor: bool,
+    pub hardware_platform: bool,
+    pub os: bool,
+}
 
-    println!("{}", output.trim_end());
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
 
+    let options = Options {
+        all: matches.get_flag(options::ALL),
+        kernel_name: matches.get_flag(options::KERNEL_NAME),
+        nodename: matches.get_flag(options::NODENAME),
+        kernel_release: matches.get_flag(options::KERNEL_RELEASE),
+        kernel_version: matches.get_flag(options::KERNEL_VERSION),
+        machine: matches.get_flag(options::MACHINE),
+        processor: matches.get_flag(options::PROCESSOR),
+        hardware_platform: matches.get_flag(options::HARDWARE_PLATFORM),
+        os: matches.get_flag(options::OS),
+    };
+    let output = UNameOutput::new(&options)?;
+    println!("{}", output.display().trim_end());
     Ok(())
 }