use anyhow::{Result, anyhow};
use znippy_common::plugin::ArchiveTypePlugin;
use znippy_common::plugins::cargo_native::CargoPlugin;
use znippy_common::plugins::conda_native::CondaPlugin;
use znippy_common::plugins::deb_native::DebPlugin;
use znippy_common::plugins::gem_native::GemPlugin;
use znippy_common::plugins::generic_native::GenericPlugin;
use znippy_common::plugins::npm_native::NpmPlugin;
use znippy_common::plugins::rpm_native::RpmPlugin;
use znippy_plugin_elf::NativeElfPlugin;
use znippy_plugin_git::NativeGitPlugin;
use znippy_plugin_maven::NativeMavenPlugin;
use znippy_plugin_media::NativeMediaPlugin;
use znippy_plugin_python::NativePythonPlugin;
use znippy_plugin_rust_toolchain::NativeRustToolchainPlugin;
use znippy_plugin_skidbladnir::NativeSkidbladnirPlugin;
pub fn builtin_handlers() -> Vec<Box<dyn ArchiveTypePlugin>> {
let mut handlers: Vec<Box<dyn ArchiveTypePlugin>> = vec![
Box::new(CargoPlugin::new()),
Box::new(NativePythonPlugin),
Box::new(NativeElfPlugin::new()),
Box::new(NativeMavenPlugin),
Box::new(NpmPlugin),
Box::new(GemPlugin),
Box::new(CondaPlugin),
Box::new(RpmPlugin),
Box::new(DebPlugin),
Box::new(NativeMediaPlugin::new()),
Box::new(NativeSkidbladnirPlugin::new()),
Box::new(NativeRustToolchainPlugin::new()),
Box::new(NativeGitPlugin::new()),
Box::new(GenericPlugin::new()),
];
handlers.extend(znippy_common::plugins::skeletons::skeleton_handlers());
handlers.sort_by_key(|h| h.type_id());
handlers
}
pub fn find_handler(query: &str) -> Result<Box<dyn ArchiveTypePlugin>> {
let q = query.to_ascii_lowercase();
builtin_handlers()
.into_iter()
.find(|h| {
let m = h.meta();
m.name.eq_ignore_ascii_case(&q) || m.aliases.iter().any(|a| a.eq_ignore_ascii_case(&q))
})
.ok_or_else(|| {
anyhow!("unknown handler '{}'; run `znippy handlers` to list available handlers", query)
})
}
pub fn print_catalog() {
let handlers = builtin_handlers();
println!("Package handlers ({}):\n", handlers.len());
for h in &handlers {
let m = h.meta();
let aliases = if m.aliases.is_empty() {
String::new()
} else {
format!(" (aliases: {})", m.aliases.join(", "))
};
println!(" • {}{} [type_id {}]", m.name, aliases, m.type_id);
if !m.ecosystem.is_empty() {
println!(" ecosystem: {}", m.ecosystem);
}
if !m.extensions.is_empty() {
println!(" extensions: {}", m.extensions.join(" "));
}
if !m.description.is_empty() {
println!(" {}", m.description);
}
for c in &m.commands {
println!(" cmd `{} {}` — {}", m.name, c.name, c.about);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
#[test]
fn every_type_id_in_the_register_is_unique() {
let mut seen: HashMap<i8, String> = HashMap::new();
for h in builtin_handlers() {
let m = h.meta();
if let Some(prev) = seen.insert(m.type_id, m.name.clone()) {
panic!("type_id {} claimed by both '{}' and '{}'", m.type_id, prev, m.name);
}
}
}
#[test]
fn every_name_and_alias_in_the_register_is_unique() {
let mut seen: HashMap<String, String> = HashMap::new();
for h in builtin_handlers() {
let m = h.meta();
for sel in std::iter::once(&m.name).chain(m.aliases.iter()) {
let key = sel.to_ascii_lowercase();
if let Some(prev) = seen.insert(key, m.name.clone()) {
panic!("selector '{}' claimed by both '{}' and '{}'", sel, prev, m.name);
}
}
}
}
#[test]
fn every_declared_selector_resolves_back_to_its_own_handler() {
for h in builtin_handlers() {
let m = h.meta();
for sel in std::iter::once(&m.name).chain(m.aliases.iter()) {
let got = find_handler(sel)
.unwrap_or_else(|e| panic!("'{sel}' is advertised by '{}' but: {e}", m.name));
assert_eq!(
got.type_id(),
m.type_id,
"--format {sel} is advertised by '{}' (type_id {}) but resolves to \
'{}' (type_id {})",
m.name,
m.type_id,
got.name(),
got.type_id(),
);
}
assert_eq!(find_handler(&m.name.to_ascii_uppercase()).unwrap().type_id(), m.type_id);
}
}
#[test]
fn the_no_package_handler_is_reachable_by_every_word_for_it() {
for sel in ["generic", "none", "raw", "plain", "blob", "GENERIC", "None"] {
let h = find_handler(sel).unwrap_or_else(|e| panic!("--format {sel}: {e}"));
assert_eq!(h.name(), "generic", "--format {sel} reached '{}'", h.name());
assert_eq!(h.type_id(), 26, "--format {sel} reached type_id {}", h.type_id());
}
let g = find_handler("generic").unwrap();
assert!(!g.matches_path("blob/9f2c1e0b7a4d3f8c"), "generic must claim no path");
assert!(!g.matches_path("serde-1.0.200.crate"), "generic must not steal cargo's");
}
#[test]
fn an_unknown_format_is_refused_and_says_where_to_look() {
let e = find_handler("nexus")
.err()
.expect("an unknown --format must be refused, never silently defaulted")
.to_string();
assert!(e.contains("nexus"), "the message must name what was asked for: {e}");
assert!(e.contains("znippy handlers"), "the message must name the door: {e}");
}
}
#[cfg(test)]
mod elf_register_tests {
use super::*;
#[test]
fn format_elf_selects_the_real_handler_and_nothing_else_answers_to_it() {
let h = find_handler("elf").expect("elf must resolve");
assert_eq!(h.type_id(), znippy_plugin_elf::ELF_TYPE_ID);
assert!(
!h.schema_fields().is_empty(),
"the skeleton declared no columns; the real handler must"
);
assert_eq!(h.schema_fields().len(), 22);
for name in ["elf", "binary", "so"] {
let matches: Vec<i8> = builtin_handlers()
.iter()
.filter(|h| {
let m = h.meta();
m.name.eq_ignore_ascii_case(name)
|| m.aliases.iter().any(|a| a.eq_ignore_ascii_case(name))
})
.map(|h| h.type_id())
.collect();
assert_eq!(
matches,
vec![znippy_plugin_elf::ELF_TYPE_ID],
"'{name}' must resolve to exactly one handler"
);
}
}
}