use std::sync::Arc;
use crate::backend::DeclarativeBackend;
pub type SniffFn = dyn Fn(&[u8]) -> bool + Send + Sync;
#[derive(Clone, Default)]
pub struct BackendMatcher {
extensions: Vec<String>,
media_types: Vec<String>,
sniff: Option<Arc<SniffFn>>,
}
impl BackendMatcher {
pub fn new() -> Self {
Self::default()
}
pub fn extensions<I, S>(mut self, extensions: I) -> Self
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
self.extensions.extend(
extensions
.into_iter()
.map(|e| {
e.as_ref()
.trim()
.trim_start_matches('.')
.to_ascii_lowercase()
})
.filter(|e| !e.is_empty()),
);
self
}
pub fn media_types<I, S>(mut self, media_types: I) -> Self
where
I: IntoIterator<Item = S>,
S: AsRef<str>,
{
self.media_types.extend(
media_types
.into_iter()
.map(|m| essence(m.as_ref()))
.filter(|m| !m.is_empty()),
);
self
}
pub fn sniff(mut self, check: impl Fn(&[u8]) -> bool + Send + Sync + 'static) -> Self {
self.sniff = Some(Arc::new(check));
self
}
pub fn extension_list(&self) -> &[String] {
&self.extensions
}
pub fn media_type_list(&self) -> &[String] {
&self.media_types
}
pub fn has_sniff(&self) -> bool {
self.sniff.is_some()
}
pub fn matches(&self, extension: Option<&str>, media_type: Option<&str>, bytes: &[u8]) -> bool {
if let Some(ext) = extension {
let ext = ext.trim_start_matches('.');
if self.extensions.iter().any(|e| e.eq_ignore_ascii_case(ext)) {
return true;
}
}
if let Some(mt) = media_type {
let mt = essence(mt);
if !mt.is_empty() && self.media_types.contains(&mt) {
return true;
}
}
self.sniff.as_ref().is_some_and(|check| check(bytes))
}
}
impl std::fmt::Debug for BackendMatcher {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BackendMatcher")
.field("extensions", &self.extensions)
.field("media_types", &self.media_types)
.field("sniff", &self.sniff.is_some())
.finish()
}
}
#[derive(Clone)]
pub struct RegisteredBackend {
name: String,
matcher: BackendMatcher,
backend: Arc<dyn DeclarativeBackend + Send + Sync>,
priority: i32,
}
impl RegisteredBackend {
pub(crate) fn new(
name: String,
matcher: BackendMatcher,
backend: Arc<dyn DeclarativeBackend + Send + Sync>,
priority: i32,
) -> Self {
Self {
name,
matcher,
backend,
priority,
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn matcher(&self) -> &BackendMatcher {
&self.matcher
}
pub fn priority(&self) -> i32 {
self.priority
}
pub fn backend(&self) -> &(dyn DeclarativeBackend + Send + Sync) {
self.backend.as_ref()
}
}
impl std::fmt::Debug for RegisteredBackend {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RegisteredBackend")
.field("name", &self.name)
.field("matcher", &self.matcher)
.field("priority", &self.priority)
.finish()
}
}
fn essence(media_type: &str) -> String {
media_type
.split(';')
.next()
.unwrap_or("")
.trim()
.to_ascii_lowercase()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn matchers_take_extension_media_type_or_content() {
let m = BackendMatcher::new()
.extensions([".RTF2", "rtf2x"])
.media_types(["Application/X-RTF2; charset=utf-8"])
.sniff(|b| b.starts_with(b"{\\rtf2"));
assert_eq!(m.extension_list(), ["rtf2", "rtf2x"]);
assert_eq!(m.media_type_list(), ["application/x-rtf2"]);
assert!(m.matches(Some("rtf2"), None, b""));
assert!(m.matches(Some(".RTF2X"), None, b""));
assert!(m.matches(None, Some("application/x-rtf2;charset=latin1"), b""));
assert!(m.matches(Some("bin"), None, b"{\\rtf2 hello}"));
assert!(!m.matches(Some("rtf"), Some("text/plain"), b"{\\rtf1 x}"));
assert!(!BackendMatcher::new().matches(Some("rtf2"), Some("x/y"), b"anything"));
assert!(format!("{m:?}").contains("sniff: true"));
}
}