use std::fmt;
#[derive(Debug, Clone)]
pub struct RangeViolation {
pub path: String,
pub value: f64,
pub min: Option<f64>,
pub max: Option<f64>,
}
impl fmt::Display for RangeViolation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let lo = self
.min
.map_or_else(|| "-inf".to_owned(), |v| v.to_string());
let hi = self.max.map_or_else(|| "inf".to_owned(), |v| v.to_string());
write!(
f,
"{} must be {}..={}, got {}",
self.path, lo, hi, self.value
)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ErrorKind {
Platform,
Parse,
Resolution,
Io,
}
#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
FeatureDisabled {
name: &'static str,
needed_for: &'static str,
},
PlatformUnsupported {
platform: &'static str,
},
UnknownPreset {
name: String,
known: &'static [&'static str],
},
WatchUnavailable {
reason: &'static str,
},
NoVariant {
mode: crate::theme::ColorMode,
},
Toml(toml::de::Error),
Io {
path: std::path::PathBuf,
source: std::io::Error,
},
ResolutionIncomplete {
missing: Vec<String>,
},
ResolutionInvalid {
errors: Vec<RangeViolation>,
},
ReaderFailed {
reader: &'static str,
source: Box<dyn std::error::Error + Send + Sync>,
},
}
impl Error {
#[must_use]
pub fn kind(&self) -> ErrorKind {
match self {
Error::FeatureDisabled { .. } => ErrorKind::Platform,
Error::PlatformUnsupported { .. } => ErrorKind::Platform,
Error::WatchUnavailable { .. } => ErrorKind::Platform,
Error::NoVariant { .. } => ErrorKind::Resolution,
Error::ReaderFailed { .. } => ErrorKind::Platform,
Error::UnknownPreset { .. } => ErrorKind::Parse,
Error::Toml(_) => ErrorKind::Parse,
Error::Io { .. } => ErrorKind::Io,
Error::ResolutionIncomplete { .. } => ErrorKind::Resolution,
Error::ResolutionInvalid { .. } => ErrorKind::Resolution,
}
}
}
impl Error {
pub(crate) fn in_variant(self, mode: crate::theme::ColorMode) -> Self {
let table = match mode {
crate::theme::ColorMode::Light => "light",
crate::theme::ColorMode::Dark => "dark",
};
match self {
Error::ResolutionIncomplete { missing } => Error::ResolutionIncomplete {
missing: missing
.into_iter()
.map(|path| format!("{table}.{path}"))
.collect(),
},
Error::ResolutionInvalid { errors } => Error::ResolutionInvalid {
errors: errors
.into_iter()
.map(|rv| {
if rv.path.starts_with("context.") {
rv
} else {
RangeViolation {
path: format!("{table}.{}", rv.path),
..rv
}
}
})
.collect(),
},
other => other,
}
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::FeatureDisabled { name, needed_for } => {
write!(f, "feature \"{name}\" is required for {needed_for}")
}
Error::PlatformUnsupported { platform } => {
write!(f, "platform not supported: {platform}")
}
Error::UnknownPreset { name, known: [] } => {
write!(
f,
"unknown preset \"{name}\": this platform has no OS generations to choose between"
)
}
Error::UnknownPreset { name, known } => {
write!(
f,
"unknown preset \"{name}\"; available: {}",
known.join(", ")
)
}
Error::WatchUnavailable { reason } => {
write!(f, "theme watching unavailable: {reason}")
}
Error::NoVariant { mode } => {
write!(
f,
"theme defines neither a light nor a dark variant (requested {mode:?})"
)
}
Error::Toml(err) => write!(f, "TOML error: {err}"),
Error::Io { path, source } => {
write!(f, "cannot read theme file `{}`: {source}", path.display())
}
Error::ResolutionIncomplete { missing } => {
write!(
f,
"theme resolution failed: {} missing field(s):",
missing.len()
)?;
let categories: &[&str] = &["root defaults", "text scale", "widget fields"];
for &cat in categories {
let fields: Vec<&str> = missing
.iter()
.filter(|field| field_category(field) == cat)
.map(|s| s.as_str())
.collect();
if fields.is_empty() {
continue;
}
write!(f, "\n [{cat}]")?;
for field in &fields {
write!(f, "\n - {field}")?;
}
}
let has_root = missing
.iter()
.any(|field| field_category(field) == "root defaults");
if has_root {
write!(
f,
"\n hint: root defaults drive widget inheritance; \
consider using Theme::preset(name) and then Theme::merge() to inherit from a complete preset"
)?;
}
Ok(())
}
Error::ResolutionInvalid { errors } => {
write!(
f,
"theme resolution failed: {} range violation(s):",
errors.len()
)?;
for violation in errors {
write!(f, "\n - {violation}")?;
}
Ok(())
}
Error::ReaderFailed { reader, source } => {
write!(f, "{reader} reader failed: {source}")
}
}
}
}
fn field_category(field: &str) -> &'static str {
let field = field
.strip_prefix("light.")
.or_else(|| field.strip_prefix("dark."))
.unwrap_or(field);
match field.split('.').next() {
Some("defaults") => "root defaults",
Some("text_scale") => "text scale",
_ => "widget fields",
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Error::Toml(err) => Some(err),
Error::Io { source, .. } => Some(source),
Error::ReaderFailed { source, .. } => Some(source.as_ref()),
Error::FeatureDisabled { .. }
| Error::PlatformUnsupported { .. }
| Error::UnknownPreset { .. }
| Error::WatchUnavailable { .. }
| Error::NoVariant { .. }
| Error::ResolutionIncomplete { .. }
| Error::ResolutionInvalid { .. } => None,
}
}
}
impl From<toml::de::Error> for Error {
fn from(err: toml::de::Error) -> Self {
Error::Toml(err)
}
}
impl From<toml::ser::Error> for Error {
fn from(err: toml::ser::Error) -> Self {
Error::ReaderFailed {
reader: reader_names::TOML_SERIALIZER,
source: Box::new(err),
}
}
}
macro_rules! reader_names {
($($(#[$meta:meta])* $name:ident = $value:literal;)*) => {
$($(#[$meta])* pub(crate) const $name: &str = $value;)*
#[cfg(test)]
pub(crate) const ALL: &[&str] = &[$($value),*];
};
}
pub(crate) mod reader_names {
reader_names! {
#[cfg_attr(not(all(target_os = "windows", feature = "windows")), allow(dead_code))]
WINDOWS = "windows";
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
MACOS = "macos";
ICON_THEME = "icon-theme";
TOML_SERIALIZER = "toml-serializer";
PRESET_CACHE = "preset-cache";
#[cfg_attr(not(feature = "svg-rasterize"), allow(dead_code))]
SVG_RASTERIZER = "svg-rasterizer";
#[cfg_attr(
not(all(feature = "watch", feature = "kde", target_os = "linux")),
allow(dead_code)
)]
KDE_WATCHER = "kde-watcher";
#[cfg_attr(
not(all(feature = "watch", feature = "portal", target_os = "linux")),
allow(dead_code)
)]
GNOME_WATCHER = "gnome-watcher";
#[cfg_attr(
not(all(feature = "watch", feature = "windows", target_os = "windows")),
allow(dead_code)
)]
WINDOWS_WATCHER = "windows-watcher";
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
#[test]
fn reader_names_are_lowercase_kebab_case_and_unique() {
for name in reader_names::ALL {
assert!(
!name.is_empty()
&& !name.starts_with('-')
&& !name.ends_with('-')
&& name
.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-'),
"{name:?} is not lowercase kebab-case"
);
}
let mut sorted = reader_names::ALL.to_vec();
sorted.sort_unstable();
assert!(sorted.windows(2).all(|w| w[0] != w[1]), "duplicate name");
}
#[test]
fn kind_platform_for_feature_disabled() {
let err = Error::FeatureDisabled {
name: "kde",
needed_for: "KDE theme detection",
};
assert_eq!(err.kind(), ErrorKind::Platform);
}
#[test]
fn kind_platform_for_platform_unsupported() {
let err = Error::PlatformUnsupported { platform: "wasm" };
assert_eq!(err.kind(), ErrorKind::Platform);
}
#[test]
fn kind_platform_for_watch_unavailable() {
let err = Error::WatchUnavailable {
reason: "notify crate not compiled",
};
assert_eq!(err.kind(), ErrorKind::Platform);
}
#[test]
fn kind_platform_for_reader_failed() {
let err = Error::ReaderFailed {
reader: reader_names::ICON_THEME,
source: Box::new(std::io::Error::other("dbus down")),
};
assert_eq!(err.kind(), ErrorKind::Platform);
}
#[test]
fn kind_parse_for_unknown_preset() {
let err = Error::UnknownPreset {
name: "foobar".into(),
known: &["adwaita", "kde-breeze"],
};
assert_eq!(err.kind(), ErrorKind::Parse);
}
#[test]
fn kind_parse_for_toml() {
let toml_err: Result<toml::Value, toml::de::Error> = toml::from_str("=invalid");
let err = Error::Toml(toml_err.unwrap_err());
assert_eq!(err.kind(), ErrorKind::Parse);
}
#[test]
fn kind_resolution_for_incomplete() {
let err = Error::ResolutionIncomplete {
missing: vec!["defaults.accent_color".into()],
};
assert_eq!(err.kind(), ErrorKind::Resolution);
}
#[test]
fn kind_resolution_for_invalid() {
let err = Error::ResolutionInvalid {
errors: vec![RangeViolation {
path: "button.min_width_px".into(),
value: -5.0,
min: Some(0.0),
max: None,
}],
};
assert_eq!(err.kind(), ErrorKind::Resolution);
}
#[test]
fn kind_io_for_io() {
let err = Error::Io {
path: "theme.toml".into(),
source: std::io::Error::other("disk failure"),
};
assert_eq!(err.kind(), ErrorKind::Io);
}
#[test]
fn error_is_send_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<Error>();
}
#[test]
fn display_feature_disabled_includes_name_and_needed_for() {
let err = Error::FeatureDisabled {
name: "kde",
needed_for: "KDE theme detection",
};
let msg = err.to_string();
assert!(msg.contains("kde"), "got: {msg}");
assert!(msg.contains("KDE theme detection"), "got: {msg}");
}
#[test]
fn display_resolution_incomplete_categorizes_fields() {
let err = Error::ResolutionIncomplete {
missing: vec![
"defaults.accent_color".into(),
"button.font.color".into(),
"window.border.corner_radius_px".into(),
],
};
let msg = err.to_string();
assert!(msg.contains("3 missing field(s)"), "got: {msg}");
assert!(msg.contains("[root defaults]"), "got: {msg}");
assert!(msg.contains("defaults.accent_color"), "got: {msg}");
assert!(msg.contains("[widget fields]"), "got: {msg}");
assert!(msg.contains("button.font.color"), "got: {msg}");
assert!(msg.contains("window.border.corner_radius_px"), "got: {msg}");
assert!(msg.contains("hint:"), "got: {msg}");
assert!(msg.contains("preset"), "got: {msg}");
}
#[test]
fn display_resolution_incomplete_no_hint_without_root_defaults() {
let err = Error::ResolutionIncomplete {
missing: vec!["button.font.color".into()],
};
let msg = err.to_string();
assert!(msg.contains("[widget fields]"), "got: {msg}");
assert!(!msg.contains("hint:"), "got: {msg}");
}
#[test]
fn display_no_variant_says_both_variants_are_missing() {
let err = Error::NoVariant {
mode: crate::theme::ColorMode::Dark,
};
assert_eq!(
err.to_string(),
"theme defines neither a light nor a dark variant (requested Dark)"
);
}
#[test]
fn display_resolution_incomplete_groups_text_scale() {
let err = Error::ResolutionIncomplete {
missing: vec!["text_scale.caption".into(), "defaults.font.family".into()],
};
let msg = err.to_string();
assert!(msg.contains("[text scale]"), "got: {msg}");
assert!(msg.contains("[root defaults]"), "got: {msg}");
}
#[test]
fn in_variant_prefixes_a_variant_path_and_not_the_context() {
let violation = |path: &str| RangeViolation {
path: path.into(),
value: 0.0,
min: Some(f64::MIN_POSITIVE),
max: None,
};
let err = Error::ResolutionInvalid {
errors: vec![
violation("context.font_dpi"),
violation("button.min_height_px"),
],
}
.in_variant(crate::theme::ColorMode::Dark);
let Error::ResolutionInvalid { errors } = err else {
panic!("expected ResolutionInvalid, got: {err:?}");
};
let paths: Vec<&str> = errors.iter().map(|rv| rv.path.as_str()).collect();
assert_eq!(paths, ["context.font_dpi", "dark.button.min_height_px"]);
}
#[test]
fn display_resolution_incomplete_groups_variant_prefixed_paths() {
let err = Error::ResolutionIncomplete {
missing: vec![
"dark.text_scale.caption".into(),
"light.defaults.icon_sizes.toolbar_px".into(),
"light.button.min_height_px".into(),
],
};
let msg = err.to_string();
assert!(
msg.contains("[text scale]\n - dark.text_scale.caption"),
"got: {msg}"
);
assert!(
msg.contains("[root defaults]\n - light.defaults.icon_sizes.toolbar_px"),
"got: {msg}"
);
assert!(
msg.contains("[widget fields]\n - light.button.min_height_px"),
"got: {msg}"
);
assert!(msg.contains("hint:"), "got: {msg}");
}
#[test]
fn display_resolution_incomplete_widget_category() {
let err = Error::ResolutionIncomplete {
missing: vec!["button.font.color".into()],
};
let msg = err.to_string();
assert!(msg.contains("[widget fields]"), "got: {msg}");
assert!(!msg.contains("hint:"), "got: {msg}");
}
#[test]
fn display_resolution_invalid_lists_violations() {
let err = Error::ResolutionInvalid {
errors: vec![
RangeViolation {
path: "button.min_width_px".into(),
value: -5.0,
min: Some(0.0),
max: None,
},
RangeViolation {
path: "slider.track_height_px".into(),
value: 200.0,
min: Some(1.0),
max: Some(100.0),
},
],
};
let msg = err.to_string();
assert!(msg.contains("2 range violation(s)"), "got: {msg}");
assert!(msg.contains("button.min_width_px"), "got: {msg}");
assert!(msg.contains("-5"), "got: {msg}");
assert!(msg.contains("slider.track_height_px"), "got: {msg}");
assert!(msg.contains("200"), "got: {msg}");
}
#[test]
fn display_unknown_preset_shows_name_and_available() {
let err = Error::UnknownPreset {
name: "foobar".into(),
known: &["adwaita", "kde-breeze"],
};
let msg = err.to_string();
assert!(msg.contains("foobar"), "got: {msg}");
assert!(msg.contains("adwaita"), "got: {msg}");
assert!(msg.contains("kde-breeze"), "got: {msg}");
}
#[test]
fn display_unknown_preset_without_presets_says_so() {
let err = Error::UnknownPreset {
name: "adwaita".into(),
known: &[],
};
assert_eq!(
err.to_string(),
"unknown preset \"adwaita\": this platform has no OS generations to choose between"
);
}
#[test]
fn source_some_for_io() {
let err = Error::Io {
path: "theme.toml".into(),
source: std::io::Error::other("disk failure"),
};
assert!(
std::error::Error::source(&err).is_some(),
"Io should return Some from source()"
);
}
#[test]
fn source_some_for_reader_failed() {
let err = Error::ReaderFailed {
reader: reader_names::ICON_THEME,
source: Box::new(std::io::Error::other("dbus down")),
};
let source = std::error::Error::source(&err);
assert!(
source.is_some(),
"ReaderFailed should return Some from source()"
);
assert!(source.unwrap().to_string().contains("dbus down"));
}
#[test]
fn source_some_for_toml() {
let toml_err: Result<toml::Value, toml::de::Error> = toml::from_str("=invalid");
let err = Error::Toml(toml_err.unwrap_err());
assert!(
std::error::Error::source(&err).is_some(),
"Toml should return Some from source()"
);
}
#[test]
fn source_none_for_feature_disabled() {
let err = Error::FeatureDisabled {
name: "kde",
needed_for: "detection",
};
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn source_none_for_platform_unsupported() {
let err = Error::PlatformUnsupported { platform: "wasm" };
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn source_none_for_watch_unavailable() {
let err = Error::WatchUnavailable {
reason: "not compiled",
};
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn source_none_for_unknown_preset() {
let err = Error::UnknownPreset {
name: "x".into(),
known: &[],
};
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn source_none_for_resolution_incomplete() {
let err = Error::ResolutionIncomplete {
missing: vec!["a".into()],
};
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn source_none_for_resolution_invalid() {
let err = Error::ResolutionInvalid {
errors: vec![RangeViolation {
path: "x".into(),
value: 0.0,
min: None,
max: None,
}],
};
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn from_toml_de_error_produces_toml_variant() {
let toml_err: Result<toml::Value, toml::de::Error> = toml::from_str("=invalid");
let err: Error = toml_err.unwrap_err().into();
match &err {
Error::Toml(_) => {} other => panic!("expected Toml variant, got: {other:?}"),
}
}
#[test]
fn display_io_names_path_and_source() {
let err = Error::Io {
path: "/themes/my-theme.toml".into(),
source: std::io::Error::new(std::io::ErrorKind::NotFound, "missing file"),
};
assert_eq!(
err.to_string(),
"cannot read theme file `/themes/my-theme.toml`: missing file"
);
}
#[test]
fn error_kind_derives() {
let k = ErrorKind::Platform;
let dbg = format!("{k:?}");
assert!(dbg.contains("Platform"));
let k2 = k;
let k3 = k2;
assert_eq!(k, k3);
assert_eq!(ErrorKind::Parse, ErrorKind::Parse);
assert_ne!(ErrorKind::Io, ErrorKind::Resolution);
}
#[test]
fn range_violation_derives_debug_clone() {
let v = RangeViolation {
path: "x".into(),
value: 1.0,
min: Some(0.0),
max: Some(10.0),
};
let dbg = format!("{v:?}");
assert!(dbg.contains("RangeViolation"));
let v2 = v.clone();
assert_eq!(v2.path, "x");
assert!((v2.value - 1.0).abs() < f64::EPSILON);
}
#[test]
fn range_violation_display_both_bounds() {
let v = RangeViolation {
path: "button.min_width_px".into(),
value: -5.0,
min: Some(0.0),
max: Some(1000.0),
};
let msg = v.to_string();
assert!(msg.contains("button.min_width_px"), "got: {msg}");
assert!(msg.contains("0..=1000"), "got: {msg}");
assert!(msg.contains("-5"), "got: {msg}");
}
#[test]
fn range_violation_display_open_max() {
let v = RangeViolation {
path: "x".into(),
value: -1.0,
min: Some(0.0),
max: None,
};
let msg = v.to_string();
assert!(msg.contains("0..=inf"), "got: {msg}");
}
#[test]
fn range_violation_display_open_min() {
let v = RangeViolation {
path: "x".into(),
value: 999.0,
min: None,
max: Some(100.0),
};
let msg = v.to_string();
assert!(msg.contains("-inf..=100"), "got: {msg}");
}
}