use crate::format::Format;
pub const SHIM_FORMATS: [Format; 7] = [
Format::BIN,
Format::OCT,
Format::DEC,
Format::HEX,
Format::Char,
Format::B64,
Format::B32,
];
const CORE_BASES: [(Format, &str); 4] = [
(Format::BIN, "2"),
(Format::OCT, "8"),
(Format::DEC, "10"),
(Format::HEX, "16"),
];
pub const SELF_NAMES: [&str; 2] = ["from2to", "f2t"];
pub const SHORT_NAME: &str = "f2t";
pub const DETECT_NAME: &str = "whatbase";
pub fn shorthands() -> Vec<(String, Format, Format)> {
let mut out = Vec::new();
for (from, fd) in CORE_BASES {
for (to, td) in CORE_BASES {
out.push((format!("{fd}2{td}"), from, to));
}
}
out
}
pub fn shim_names() -> Vec<(String, Format, Format)> {
let mut out = Vec::new();
for from in SHIM_FORMATS {
for to in SHIM_FORMATS {
if from != to {
out.push((format!("{}2{}", from.name(), to.name()), from, to));
}
}
}
for (base, _) in CORE_BASES {
out.push((format!("{}2ascii", base.name()), base, Format::Char));
out.push((format!("ascii2{}", base.name()), Format::Char, base));
}
out
}
pub fn basename(argv0: &str) -> String {
let path = std::path::Path::new(argv0);
path.file_stem()
.map(|s| s.to_string_lossy().to_ascii_lowercase())
.unwrap_or_else(|| argv0.to_ascii_lowercase())
}
pub fn resolve(cmd: &str) -> Option<(Format, Format)> {
let cmd = cmd.to_ascii_lowercase();
if SELF_NAMES.contains(&cmd.as_str()) {
return None;
}
for (name, from, to) in shorthands() {
if name == cmd {
return Some((from, to));
}
}
let mut found = None;
for (i, ch) in cmd.char_indices() {
if ch != '2' {
continue;
}
let (left, right) = (&cmd[..i], &cmd[i + 1..]);
if let (Some(f), Some(t)) = (Format::parse(left), Format::parse(right)) {
if found.is_some() {
return None; }
found = Some((f, t));
}
}
found
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
#[test]
fn resolves_word_names() {
assert_eq!(resolve("hex2bin"), Some((Format::HEX, Format::BIN)));
assert_eq!(resolve("dec2char"), Some((Format::DEC, Format::Char)));
assert_eq!(resolve("dec2ascii"), Some((Format::DEC, Format::Char)));
assert_eq!(resolve("b642hex"), Some((Format::B64, Format::HEX)));
assert_eq!(resolve("char2b32"), Some((Format::Char, Format::B32)));
}
#[test]
fn resolves_numeric_shorthands() {
assert_eq!(resolve("1628"), Some((Format::HEX, Format::OCT)));
assert_eq!(resolve("10216"), Some((Format::DEC, Format::HEX)));
assert_eq!(resolve("2216"), Some((Format::BIN, Format::HEX)));
assert_eq!(resolve("822"), Some((Format::OCT, Format::BIN)));
}
#[test]
fn self_names_are_not_conversions() {
assert_eq!(resolve("f2t"), None);
assert_eq!(resolve("from2to"), None);
assert_eq!(resolve(DETECT_NAME), None);
}
#[test]
fn every_shorthand_has_exactly_one_parse() {
let bases = ["2", "8", "10", "16"];
for (name, from, to) in shorthands() {
let parses: Vec<_> = name
.char_indices()
.filter(|(_, c)| *c == '2')
.filter_map(|(i, _)| {
let (l, r) = (&name[..i], &name[i + 1..]);
(bases.contains(&l) && bases.contains(&r)).then(|| (l.to_string(), r.to_string()))
})
.collect();
assert_eq!(parses.len(), 1, "{name} has {} parses: {parses:?}", parses.len());
assert_eq!(resolve(&name), Some((from, to)), "{name} resolved wrong");
}
}
#[test]
fn shim_names_are_unique_and_resolve_back() {
let names = shim_names();
let mut seen: HashMap<&str, ()> = HashMap::new();
for (name, from, to) in &names {
assert!(seen.insert(name, ()).is_none(), "duplicate shim {name}");
assert_eq!(resolve(name), Some((*from, *to)), "{name} resolved wrong");
}
assert_eq!(names.len(), 50);
}
#[test]
fn shorthands_resolve_but_are_never_installed() {
assert_eq!(resolve("1628"), Some((Format::HEX, Format::OCT)));
let installed = shim_names();
for (name, _, _) in shorthands() {
assert!(
!installed.iter().any(|(n, _, _)| *n == name),
"{name} must not be installed as a command"
);
}
}
#[test]
fn basename_strips_path_and_extension() {
assert_eq!(basename(r"C:\Users\x\.cargo\bin\hex2bin.exe"), "hex2bin");
assert_eq!(basename("/usr/local/bin/dec2char"), "dec2char");
assert_eq!(basename("HEX2BIN.EXE"), "hex2bin");
}
}