Skip to content

Commit

Permalink
uname: Refactor into public fns for Nushell (uutils#5921)
Browse files Browse the repository at this point in the history 
* Refactor to use options struct and make it public for Nushell

* Return the output for use in nushell

* wip:opt1

* Add UNameOutput struct instead

* Apply req changes

* change back to mod options

* uname: add empty line & fix position of comment

---------

Co-authored-by: Daniel Hofstetter <daniel.hofstetter@42dh.com>
  • Loading branch information
@dmatos2012 @cakebaker @ysthakur
2 people authored and ysthakur committed Feb 27, 2024
1 parent 89da5a7 commit 040f0ed
Showing 1 changed file with 106 additions and 67 deletions.
173 changes: 106 additions & 67 deletions src/uu/uname/src/uname.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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(())
}

Expand Down

0 comments on commit 040f0ed

Please sign in to comment.