use crate::error::SkipStep;
use color_eyre::eyre::Result;
use std::env;
use std::ffi::OsStr;
use std::fmt::Debug;
use std::path::{Path, PathBuf};
use tracing::{debug, error};
pub trait PathExt
where
Self: Sized,
{
fn if_exists(self) -> Option<Self>;
fn is_descendant_of(&self, ancestor: &Path) -> bool;
fn require(self) -> Result<Self>;
}
impl<T> PathExt for T
where
T: AsRef<Path>,
{
fn if_exists(self) -> Option<Self> {
if self.as_ref().exists() {
debug!("Path {:?} exists", self.as_ref());
Some(self)
} else {
debug!("Path {:?} doesn't exist", self.as_ref());
None
}
}
fn is_descendant_of(&self, ancestor: &Path) -> bool {
self.as_ref().iter().zip(ancestor.iter()).all(|(a, b)| a == b)
}
fn require(self) -> Result<Self> {
if self.as_ref().exists() {
debug!("Path {:?} exists", self.as_ref());
Ok(self)
} else {
Err(SkipStep(format!("Path {:?} doesn't exist", self.as_ref())).into())
}
}
}
pub fn which<T: AsRef<OsStr> + Debug>(binary_name: T) -> Option<PathBuf> {
match which_crate::which(&binary_name) {
Ok(path) => {
debug!("Detected {:?} as {:?}", &path, &binary_name);
Some(path)
}
Err(e) => {
match e {
which_crate::Error::CannotFindBinaryPath => {
debug!("Cannot find {:?}", &binary_name);
}
_ => {
error!("Detecting {:?} failed: {}", &binary_name, e);
}
}
None
}
}
}
pub fn editor() -> Vec<String> {
env::var("EDITOR")
.unwrap_or_else(|_| String::from(if cfg!(windows) { "notepad" } else { "vi" }))
.split_whitespace()
.map(|s| s.to_owned())
.collect()
}
pub fn require<T: AsRef<OsStr> + Debug>(binary_name: T) -> Result<PathBuf> {
match which_crate::which(&binary_name) {
Ok(path) => {
debug!("Detected {:?} as {:?}", &path, &binary_name);
Ok(path)
}
Err(e) => match e {
which_crate::Error::CannotFindBinaryPath => {
Err(SkipStep(format!("Cannot find {:?} in PATH", &binary_name)).into())
}
_ => {
panic!("Detecting {:?} failed: {}", &binary_name, e);
}
},
}
}
#[allow(dead_code)]
pub fn require_option<T>(option: Option<T>, cause: String) -> Result<T> {
if let Some(value) = option {
Ok(value)
} else {
Err(SkipStep(cause).into())
}
}
#[cfg(target_family = "unix")]
pub fn hostname() -> Result<String> {
use std::ffi;
extern crate libc;
unsafe {
let buf_size = libc::sysconf(libc::_SC_HOST_NAME_MAX) as usize;
let mut buf = Vec::<u8>::with_capacity(buf_size + 1);
if libc::gethostname(buf.as_mut_ptr() as *mut libc::c_char, buf_size) < 0 {
return Err(SkipStep(format!("Failed to get hostname: {}", std::io::Error::last_os_error())).into());
}
let hostname_len = libc::strnlen(buf.as_ptr() as *const libc::c_char, buf_size);
buf.set_len(hostname_len);
Ok(ffi::CString::new(buf).unwrap().into_string().unwrap())
}
}
#[cfg(target_family = "windows")]
pub fn hostname() -> Result<String> {
use crate::command::CommandExt;
use std::process::Command;
Command::new("hostname")
.output_checked_utf8()
.map_err(|err| SkipStep(format!("Failed to get hostname: {err}")).into())
.map(|output| output.stdout.trim().to_owned())
}