use std::any::Any;
use crate::vdom::{Event, VElement};
pub trait CustomElement: Any {
fn tag(&self) -> &'static str
where
Self: Sized;
fn render(&self, attrs: &[(&'static str, String)], children: &[VElement]) -> VElement;
fn on_event(&mut self, _event: &Event, _ctx: &mut EventCtx<'_>) {}
}
pub fn downcast_custom<T: 'static>(elem: &dyn CustomElement) -> Option<&T> {
let any: &dyn Any = elem;
any.downcast_ref::<T>()
}
pub struct EventCtx<'a> {
pub(crate) redraw: &'a dyn Fn(),
}
impl<'a> EventCtx<'a> {
pub fn new(redraw: &'a dyn Fn()) -> Self {
Self { redraw }
}
pub fn schedule_redraw(&self) {
(self.redraw)();
}
}
#[derive(Debug)]
pub struct CustomElementFactory {
pub tag: &'static str,
pub core_version_req: &'static str,
pub crate_name: &'static str,
pub provides: &'static [&'static str],
pub factory: fn() -> Box<dyn CustomElement>,
}
#[linkme::distributed_slice]
pub static REGISTERED_COMPONENTS: [CustomElementFactory];
pub fn lookup(tag: &str) -> Option<&'static CustomElementFactory> {
REGISTERED_COMPONENTS
.iter()
.find(|factory| factory.tag == tag)
}
pub fn check_core_version(req: &str) -> Result<(), String> {
let Some(caret) = req.strip_prefix('^') else {
return Err(format!(
"неподдерживаемый формат версии: {req:?} (ожидалось ^MAJOR.MINOR)"
));
};
let parts: Vec<&str> = caret.split('.').collect();
if parts.len() < 2 || parts.len() > 3 {
return Err(format!(
"неподдерживаемый формат версии: {req:?} (ожидалось ^MAJOR.MINOR)"
));
}
let req_major: u64 = parts[0]
.parse()
.map_err(|_| format!("неверная major-версия: {req:?}"))?;
let req_minor: u64 = parts[1]
.parse()
.map_err(|_| format!("неверная minor-версия: {req:?}"))?;
let req_patch: u64 = parts
.get(2)
.and_then(|p| p.trim().parse::<u64>().ok())
.unwrap_or(0);
let cur = env!("CARGO_PKG_VERSION");
let (cur_major, cur_minor, cur_patch): (u64, u64, u64) =
parse_triple(cur).ok_or_else(|| format!("не удалось разобрать версию ядра {cur:?}"))?;
let ok = if req_major == 0 {
cur_major == 0 && cur_minor >= req_minor
} else {
cur_major == req_major
&& (cur_minor > req_minor || (cur_minor == req_minor && cur_patch >= req_patch))
};
if ok {
Ok(())
} else {
Err(format!(
"требуемая версия ядра {req:?} несовместима с текущей {cur:?}"
))
}
}
fn parse_triple(s: &str) -> Option<(u64, u64, u64)> {
let mut nums = s.split('.').take(3).map(str::trim);
let major = nums.next()?.parse::<u64>().ok()?;
let minor = nums.next()?.parse::<u64>().ok()?;
let patch = nums.next()?.parse::<u64>().ok()?;
Some((major, minor, patch))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::vdom::NodeKind;
struct FakeDatepicker;
impl CustomElement for FakeDatepicker {
fn tag(&self) -> &'static str
where
Self: Sized,
{
"datepicker"
}
fn render(&self, attrs: &[(&'static str, String)], children: &[VElement]) -> VElement {
let _ = (attrs, children);
VElement::container(
"",
NodeKind::Column,
vec![VElement::leaf(
"",
NodeKind::Text {
content: "DatePicker".to_string(),
},
)],
)
}
}
const FAKE_DATEPICKER: CustomElementFactory = CustomElementFactory {
tag: "datepicker",
core_version_req: "^0.18",
crate_name: "fake-datepicker",
provides: &["datepicker"],
factory: || Box::new(FakeDatepicker),
};
#[linkme::distributed_slice(REGISTERED_COMPONENTS)]
static FAKE_DATEPICKER_ENTRY: CustomElementFactory = FAKE_DATEPICKER;
#[test]
fn lookup_finds_registered_datepicker() {
let factory = lookup("datepicker");
assert!(factory.is_some(), "datepicker должен быть зарегистрирован");
let f = factory.unwrap();
assert_eq!(f.tag, "datepicker");
assert_eq!(f.crate_name, "fake-datepicker");
assert_eq!(f.provides, &["datepicker"]);
}
#[test]
fn lookup_unknown_returns_none() {
assert!(lookup("unknown-tag").is_none());
}
#[test]
fn check_core_version_accepts_compatible() {
assert!(check_core_version("^0.18").is_ok());
assert!(check_core_version("^0.17").is_ok());
assert!(check_core_version("^0.0").is_ok());
}
#[test]
fn check_core_version_rejects_incompatible() {
assert!(check_core_version("^0.99").is_err());
assert!(check_core_version("0.18").is_err()); assert!(check_core_version("").is_err());
}
#[test]
fn check_core_version_cares_about_patch_for_nonzero_major() {
assert!(check_core_version("^1.0.0").is_err());
}
}