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(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 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}\"; available: {}",
known.join(", ")
)
}
Error::WatchUnavailable { reason } => {
write!(f, "theme watching unavailable: {reason}")
}
Error::NoVariant { mode } => {
write!(f, "theme has no variant for {mode:?}")
}
Error::Toml(err) => write!(f, "TOML error: {err}"),
Error::Io(err) => write!(f, "I/O error: {err}"),
Error::ResolutionIncomplete { missing } => {
write!(
f,
"theme resolution failed: {} missing field(s):",
missing.len()
)?;
let categories: &[&str] =
&["root defaults", "text scale", "widget fields", "icon set"];
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 {
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(err) => Some(err),
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: "toml-serializer",
source: Box::new(err),
}
}
}
impl From<std::io::Error> for Error {
fn from(err: std::io::Error) -> Self {
Error::Io(err)
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
#[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: "kde",
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".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(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".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"), "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_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 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".into(),
value: -5.0,
min: Some(0.0),
max: None,
},
RangeViolation {
path: "slider.track_height".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"), "got: {msg}");
assert!(msg.contains("-5"), "got: {msg}");
assert!(msg.contains("slider.track_height"), "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 source_some_for_io() {
let err = Error::Io(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: "kde",
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 from_io_error_produces_io_variant_no_arc() {
let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "missing file");
let err: Error = io_err.into();
match &err {
Error::Io(e) => {
assert_eq!(e.kind(), std::io::ErrorKind::NotFound);
assert!(e.to_string().contains("missing file"));
}
other => panic!("expected Io variant, got: {other:?}"),
}
}
#[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".into(),
value: -5.0,
min: Some(0.0),
max: Some(1000.0),
};
let msg = v.to_string();
assert!(msg.contains("button.min_width"), "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}");
}
}