use std::fmt;
#[cfg(target_os = "linux")]
use crate::detect::{LinuxDesktop, parse_linux_desktop};
#[cfg(any(target_os = "linux", test))]
use crate::ReaderOutput;
use crate::model::Theme;
use crate::{OverlaySource, ReaderResult, SystemTheme};
pub(crate) fn run_pipeline(reader: ReaderResult, preset_name: &str) -> crate::Result<SystemTheme> {
let mode = reader.output.mode();
let ReaderResult {
output: reader_output,
name: reader_name,
icon_set: reader_icon_set,
layout: reader_layout,
font_dpi,
accessibility,
} = reader;
let context = match font_dpi {
Some(dpi) => crate::resolve::ResolutionContext::with_font_dpi(
dpi,
crate::detect::system_icon_theme(),
),
None => crate::resolve::ResolutionContext::from_system(),
};
let source = OverlaySource {
reader_output,
name: reader_name,
icon_set: reader_icon_set,
layout: reader_layout,
preset_name: preset_name.to_string(),
context,
overlay: None,
};
replay(source, mode, accessibility)
}
pub(crate) fn replay(
source: OverlaySource,
mode: crate::ColorMode,
accessibility: crate::AccessibilityPreferences,
) -> crate::Result<SystemTheme> {
let mut merged = Theme::preset(&source.preset_name)?;
merged.merge(
&source
.reader_output
.to_theme(&source.name, source.icon_set, &source.layout),
);
if let Some(overlay) = &source.overlay {
merged.merge(overlay);
}
let name = if source.name.is_empty() {
merged.name.clone()
} else {
source.name.clone()
};
let icon_set = merged
.icon_set
.unwrap_or_else(crate::detect::system_icon_set);
let icon_theme_of =
|variant: &Option<crate::model::ThemeMode>| -> Option<std::borrow::Cow<'static, str>> {
variant
.as_ref()
.and_then(|v| v.defaults.icon_theme.clone()) .or_else(|| merged.icon_theme.clone()) .or_else(|| source.context.icon_theme.clone()) };
let light_icon_theme = icon_theme_of(&merged.light);
let dark_icon_theme = icon_theme_of(&merged.dark);
let icon_theme = match mode {
crate::ColorMode::Light => light_icon_theme.clone(),
crate::ColorMode::Dark => dark_icon_theme.clone(),
};
crate::resolve::validate_helpers::check_font_dpi(source.context.font_dpi)?;
crate::resolve::validate_helpers::check_layout(&merged.layout)?;
let light = merged
.light
.unwrap_or_default()
.into_resolved(&source.context)
.map_err(|e| e.in_variant(crate::ColorMode::Light))?;
let dark = merged
.dark
.unwrap_or_default()
.into_resolved(&source.context)
.map_err(|e| e.in_variant(crate::ColorMode::Dark))?;
Ok(SystemTheme {
name,
mode,
light,
dark,
preset: source.preset_name.clone(),
overlay_source: source,
version_match: None,
icon_set,
icon_theme,
light_icon_theme,
dark_icon_theme,
layout: merged.layout,
accessibility,
})
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum DiagnosticEntry {
Platform(&'static str),
#[cfg(target_os = "linux")]
DesktopEnv(crate::detect::LinuxDesktop),
EnvVar {
name: &'static str,
value: String,
},
EnvVarMissing(&'static str),
ToolAvailable {
name: &'static str,
version: String,
},
ToolError(&'static str),
ToolMissing {
name: &'static str,
impact: &'static str,
},
ConfigFound {
name: &'static str,
path: std::path::PathBuf,
},
ConfigMissing {
name: &'static str,
path: std::path::PathBuf,
},
FeatureEnabled(&'static str),
FeatureDisabled {
feature: &'static str,
impact: &'static str,
},
OsGeneration {
version: String,
preset: &'static str,
version_match: VersionMatch,
},
}
impl DiagnosticEntry {
#[must_use]
pub fn name(&self) -> &str {
match self {
Self::Platform(_) => "Platform",
#[cfg(target_os = "linux")]
Self::DesktopEnv(_) => "Detected DE",
Self::EnvVar { name, .. } | Self::EnvVarMissing(name) => name,
Self::ToolAvailable { name, .. }
| Self::ToolError(name)
| Self::ToolMissing { name, .. } => name,
Self::ConfigFound { name, .. } | Self::ConfigMissing { name, .. } => name,
Self::FeatureEnabled(feature) | Self::FeatureDisabled { feature, .. } => feature,
Self::OsGeneration { .. } => "OS version",
}
}
#[must_use]
pub fn status(&self) -> &str {
match self {
Self::Platform(p) => p,
#[cfg(target_os = "linux")]
Self::DesktopEnv(_) => "detected",
Self::EnvVar { value, .. } => value.as_str(),
Self::EnvVarMissing(_) => "not set",
Self::ToolAvailable { .. } => "available",
Self::ToolError(_) => "found but returned error",
Self::ToolMissing { .. } => "not found",
Self::ConfigFound { .. } => "found",
Self::ConfigMissing { .. } => "not found",
Self::FeatureEnabled(_) => "enabled",
Self::FeatureDisabled { .. } => "disabled",
Self::OsGeneration { version, .. } => version.as_str(),
}
}
#[must_use]
pub fn detail(&self) -> Option<String> {
match self {
#[cfg(target_os = "linux")]
Self::DesktopEnv(de) => Some(format!("{de:?}")),
Self::ToolAvailable { version, .. } => Some(version.clone()),
Self::ToolMissing { impact, .. } => Some((*impact).to_string()),
Self::FeatureDisabled { impact, .. } => Some((*impact).to_string()),
Self::ConfigFound { path, .. } | Self::ConfigMissing { path, .. } => {
Some(path.display().to_string())
}
Self::OsGeneration {
preset,
version_match,
..
} => Some(format!("{preset}, {version_match}")),
_ => None,
}
}
}
impl fmt::Display for DiagnosticEntry {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Platform(p) => write!(f, "Platform: {p}"),
#[cfg(target_os = "linux")]
Self::DesktopEnv(de) => write!(f, "Detected DE: {de:?}"),
Self::EnvVar { name, value } => write!(f, "{name}: {value}"),
Self::EnvVarMissing(name) => write!(f, "{name}: not set"),
Self::ToolAvailable { name, version } => {
write!(f, "{name}: available ({version})")
}
Self::ToolError(name) => write!(f, "{name}: found but returned error"),
Self::ToolMissing { name, impact } => write!(f, "{name}: not found ({impact})"),
Self::ConfigFound { name, path } => {
write!(f, "{name}: found at {}", path.display())
}
Self::ConfigMissing { name, path } => {
write!(f, "{name}: not found at {}", path.display())
}
Self::FeatureEnabled(feature) => write!(f, "{feature} support: enabled"),
Self::FeatureDisabled { feature, impact } => {
write!(f, "{feature} support: disabled ({impact})")
}
Self::OsGeneration {
version,
preset,
version_match,
} => write!(f, "OS version: {version} ({preset}, {version_match})"),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PlatformPreset {
pub name: &'static str,
}
impl fmt::Display for PlatformPreset {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.name)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum VersionMatch {
Exact,
PresetOlder,
PresetNewer,
}
impl VersionMatch {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Exact => "exact",
Self::PresetOlder => "preset older than the OS",
Self::PresetNewer => "preset newer than the OS",
}
}
}
impl fmt::Display for VersionMatch {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) struct OsVersion {
pub(crate) major: u32,
pub(crate) minor: u32,
pub(crate) build: u32,
}
impl OsVersion {
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
pub(crate) const fn new(major: u32, minor: u32, build: u32) -> Self {
Self {
major,
minor,
build,
}
}
}
impl fmt::Display for OsVersion {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}.{}.{}", self.major, self.minor, self.build)
}
}
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Generation {
pub(crate) preset: &'static str,
pub(crate) first: OsVersion,
pub(crate) last_verified: OsVersion,
}
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
#[derive(Clone, Copy, Debug)]
pub(crate) struct GenerationTable {
pub(crate) oldest: Generation,
pub(crate) newer: &'static [Generation],
pub(crate) keys: &'static [&'static str],
}
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
impl GenerationTable {
fn rows(&self) -> impl Iterator<Item = Generation> + '_ {
std::iter::once(self.oldest).chain(self.newer.iter().copied())
}
fn row(&self, preset: &str) -> Option<Generation> {
self.rows().find(|g| g.preset == preset)
}
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
pub(crate) const MACOS_GENERATIONS: GenerationTable = GenerationTable {
oldest: Generation {
preset: "macos-monterey",
first: OsVersion::new(12, 0, 0),
last_verified: OsVersion::new(15, 0, 0),
},
newer: &[Generation {
preset: "macos-tahoe",
first: OsVersion::new(26, 0, 0),
last_verified: OsVersion::new(26, 0, 0),
}],
keys: &["macos-monterey", "macos-tahoe"],
};
#[cfg_attr(not(all(target_os = "windows", feature = "windows")), allow(dead_code))]
pub(crate) const WINDOWS_GENERATIONS: GenerationTable = GenerationTable {
oldest: Generation {
preset: "windows-11",
first: OsVersion::new(10, 0, 22000),
last_verified: OsVersion::new(10, 0, 26200),
},
newer: &[],
keys: &["windows-11"],
};
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
pub(crate) fn version_match(row: &Generation, running: OsVersion) -> VersionMatch {
if running < row.first {
VersionMatch::PresetNewer
} else if running > row.last_verified {
VersionMatch::PresetOlder
} else {
VersionMatch::Exact
}
}
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
pub(crate) fn preset_for_version(
table: &GenerationTable,
running: OsVersion,
) -> (PlatformPreset, VersionMatch) {
let row = table
.newer
.iter()
.rev()
.find(|g| g.first <= running)
.copied()
.unwrap_or(table.oldest);
(
PlatformPreset { name: row.preset },
version_match(&row, running),
)
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
pub(crate) fn macos_major(running: OsVersion) -> OsVersion {
OsVersion::new(running.major, 0, 0)
}
#[cfg_attr(not(all(target_os = "macos", feature = "macos")), allow(dead_code))]
pub(crate) fn macos_generation(running: OsVersion) -> (PlatformPreset, VersionMatch) {
preset_for_version(&MACOS_GENERATIONS, macos_major(running))
}
#[cfg_attr(not(all(target_os = "windows", feature = "windows")), allow(dead_code))]
pub(crate) fn windows_generation(running: OsVersion) -> (PlatformPreset, VersionMatch) {
preset_for_version(&WINDOWS_GENERATIONS, running)
}
#[cfg(target_os = "linux")]
pub(crate) fn linux_preset_for_de(de: LinuxDesktop) -> PlatformPreset {
match de {
LinuxDesktop::Kde => PlatformPreset { name: "kde-breeze" },
_ => PlatformPreset { name: "adwaita" },
}
}
#[must_use]
pub fn platform_preset_name() -> PlatformPreset {
#[cfg(all(target_os = "macos", feature = "macos"))]
{
macos_generation(crate::macos::os_version()).0
}
#[cfg(all(target_os = "macos", not(feature = "macos")))]
{
PlatformPreset {
name: MACOS_GENERATIONS.oldest.preset,
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
{
windows_generation(crate::windows::os_version()).0
}
#[cfg(all(target_os = "windows", not(feature = "windows")))]
{
PlatformPreset {
name: WINDOWS_GENERATIONS.oldest.preset,
}
}
#[cfg(target_os = "linux")]
{
linux_preset_for_de(crate::detect::system().refined_linux_desktop_sync())
}
#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
{
PlatformPreset { name: "adwaita" }
}
}
#[must_use]
pub fn diagnose_platform_support() -> Vec<DiagnosticEntry> {
let mut diagnostics = Vec::new();
#[cfg(target_os = "linux")]
{
diagnostics.push(DiagnosticEntry::Platform("Linux"));
match std::env::var("XDG_CURRENT_DESKTOP") {
Ok(val) if !val.is_empty() => {
let de = parse_linux_desktop(&val);
diagnostics.push(DiagnosticEntry::EnvVar {
name: "XDG_CURRENT_DESKTOP",
value: val,
});
diagnostics.push(DiagnosticEntry::DesktopEnv(de));
}
_ => {
diagnostics.push(DiagnosticEntry::EnvVarMissing("XDG_CURRENT_DESKTOP"));
diagnostics.push(DiagnosticEntry::DesktopEnv(LinuxDesktop::Unknown));
}
}
match crate::detect::run_with_timeout(
"gsettings",
&["--version"],
crate::detect::SUBPROCESS_TIMEOUT,
) {
Ok(output) if output.status.success() => {
let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
diagnostics.push(DiagnosticEntry::ToolAvailable {
name: "gsettings",
version,
});
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
diagnostics.push(DiagnosticEntry::ToolMissing {
name: "gsettings",
impact: "dark mode and icon theme detection may be limited",
});
}
Ok(_) | Err(_) => {
diagnostics.push(DiagnosticEntry::ToolError("gsettings"));
}
}
#[cfg(feature = "kde")]
{
match crate::kde::kdeglobals_path() {
Some(path) if path.exists() => {
diagnostics.push(DiagnosticEntry::ConfigFound {
name: "KDE kdeglobals",
path,
});
}
Some(path) => {
diagnostics.push(DiagnosticEntry::ConfigMissing {
name: "KDE kdeglobals",
path,
});
}
None => diagnostics.push(DiagnosticEntry::EnvVarMissing("HOME")),
}
}
#[cfg(not(feature = "kde"))]
{
diagnostics.push(DiagnosticEntry::FeatureDisabled {
feature: "KDE",
impact: "kde feature not enabled",
});
}
#[cfg(feature = "portal")]
diagnostics.push(DiagnosticEntry::FeatureEnabled("Portal"));
#[cfg(not(feature = "portal"))]
diagnostics.push(DiagnosticEntry::FeatureDisabled {
feature: "Portal",
impact: "portal feature not enabled",
});
}
#[cfg(target_os = "macos")]
{
diagnostics.push(DiagnosticEntry::Platform("macOS"));
#[cfg(feature = "macos")]
{
diagnostics.push(DiagnosticEntry::FeatureEnabled("macOS theme detection"));
let running = crate::macos::os_version();
let (preset, version_match) = macos_generation(running);
diagnostics.push(DiagnosticEntry::OsGeneration {
version: running.to_string(),
preset: preset.name,
version_match,
});
}
#[cfg(not(feature = "macos"))]
diagnostics.push(DiagnosticEntry::FeatureDisabled {
feature: "macOS theme detection",
impact: "macos feature not enabled, using subprocess fallback",
});
}
#[cfg(target_os = "windows")]
{
diagnostics.push(DiagnosticEntry::Platform("Windows"));
#[cfg(feature = "windows")]
{
diagnostics.push(DiagnosticEntry::FeatureEnabled("Windows theme detection"));
let running = crate::windows::os_version();
let (preset, version_match) = windows_generation(running);
diagnostics.push(DiagnosticEntry::OsGeneration {
version: running.to_string(),
preset: preset.name,
version_match,
});
}
#[cfg(not(feature = "windows"))]
diagnostics.push(DiagnosticEntry::FeatureDisabled {
feature: "Windows theme detection",
impact: "windows feature not enabled",
});
}
#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
{
diagnostics.push(DiagnosticEntry::Platform(
"unsupported (no native theme detection available)",
));
}
diagnostics
}
#[cfg(any(target_os = "linux", test))]
fn preset_as_reader(preset_name: &str, mode: crate::ColorMode) -> crate::Result<ReaderResult> {
let theme = Theme::preset(preset_name)?;
let is_dark = mode == crate::ColorMode::Dark;
let output = if is_dark {
ReaderOutput::Single {
mode: Box::new(theme.dark.unwrap_or_default()),
is_dark: true,
}
} else {
ReaderOutput::Single {
mode: Box::new(theme.light.unwrap_or_default()),
is_dark: false,
}
};
Ok(ReaderResult {
output,
name: theme.name,
icon_set: theme.icon_set,
layout: theme.layout,
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
})
}
pub(crate) struct SelectedReader {
pub(crate) reader: Box<dyn crate::reader::ThemeReader>,
pub(crate) preset: &'static str,
pub(crate) version_match: Option<VersionMatch>,
}
impl SelectedReader {
#[cfg_attr(
not(all(target_os = "linux", any(feature = "kde", feature = "portal"))),
allow(dead_code)
)]
fn unversioned(reader: Box<dyn crate::reader::ThemeReader>, preset: &'static str) -> Self {
Self {
reader,
preset,
version_match: None,
}
}
}
#[allow(unreachable_code)]
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::needless_return)] pub(crate) async fn select_reader() -> Option<SelectedReader> {
#[cfg(target_os = "macos")]
{
#[cfg(feature = "macos")]
{
let (preset, matched) = macos_generation(crate::macos::os_version());
return Some(SelectedReader {
reader: Box::new(crate::macos::MacosReader),
preset: preset.name,
version_match: Some(matched),
});
}
#[cfg(not(feature = "macos"))]
return None;
}
#[cfg(target_os = "windows")]
{
#[cfg(feature = "windows")]
{
let (preset, matched) = windows_generation(crate::windows::os_version());
return Some(SelectedReader {
reader: Box::new(crate::windows::WindowsReader),
preset: preset.name,
version_match: Some(matched),
});
}
#[cfg(not(feature = "windows"))]
return None;
}
#[cfg(target_os = "linux")]
{
return linux_reader(crate::detect::system().refined_linux_desktop().await);
}
#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
{
None
}
}
#[cfg(target_os = "linux")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LinuxReader {
#[cfg(feature = "kde")]
Kde,
#[cfg(all(feature = "kde", feature = "portal"))]
PortalKde,
#[cfg(feature = "portal")]
Gnome,
}
#[cfg(target_os = "linux")]
fn linux_reader_kind(refined: crate::detect::RefinedDesktop) -> Option<LinuxReader> {
match refined.desktop {
#[cfg(all(feature = "kde", feature = "portal"))]
LinuxDesktop::Kde if refined.by_kdeglobals => Some(LinuxReader::Kde),
#[cfg(all(feature = "kde", feature = "portal"))]
LinuxDesktop::Kde => Some(LinuxReader::PortalKde),
#[cfg(all(feature = "kde", not(feature = "portal")))]
LinuxDesktop::Kde => Some(LinuxReader::Kde),
#[cfg(not(feature = "kde"))]
LinuxDesktop::Kde => None,
#[cfg(feature = "portal")]
LinuxDesktop::Gnome | LinuxDesktop::Budgie => Some(LinuxReader::Gnome),
#[cfg(not(feature = "portal"))]
LinuxDesktop::Gnome | LinuxDesktop::Budgie => None,
LinuxDesktop::Xfce
| LinuxDesktop::Cinnamon
| LinuxDesktop::Mate
| LinuxDesktop::LxQt
| LinuxDesktop::Hyprland
| LinuxDesktop::Sway
| LinuxDesktop::River
| LinuxDesktop::Niri
| LinuxDesktop::Wayfire
| LinuxDesktop::CosmicDe
| LinuxDesktop::Unknown => None,
}
}
#[cfg(all(target_os = "linux", any(feature = "kde", feature = "portal")))]
fn linux_reader(refined: crate::detect::RefinedDesktop) -> Option<SelectedReader> {
let reader: Box<dyn crate::reader::ThemeReader> = match linux_reader_kind(refined)? {
#[cfg(feature = "kde")]
LinuxReader::Kde => Box::new(crate::kde::KdeReader),
#[cfg(all(feature = "kde", feature = "portal"))]
LinuxReader::PortalKde => Box::new(crate::gnome::GnomePortalKdeReader),
#[cfg(feature = "portal")]
LinuxReader::Gnome => Box::new(crate::gnome::GnomeReader),
};
Some(SelectedReader::unversioned(
reader,
linux_preset_for_de(refined.desktop).name,
))
}
#[cfg(all(target_os = "linux", not(any(feature = "kde", feature = "portal"))))]
fn linux_reader(refined: crate::detect::RefinedDesktop) -> Option<SelectedReader> {
match linux_reader_kind(refined)? {}
}
#[allow(unreachable_code)]
#[allow(clippy::needless_return)] pub(crate) async fn from_system_inner() -> crate::Result<SystemTheme> {
if let Some(selected) = select_reader().await {
let mut theme = read_through_pipeline(
selected.reader.as_ref(),
selected.preset,
crate::detect::system(),
)
.await?;
theme.version_match = selected.version_match;
return Ok(theme);
}
#[cfg(target_os = "macos")]
{
return Err(crate::Error::FeatureDisabled {
name: "macos",
needed_for: "macOS theme detection",
});
}
#[cfg(target_os = "windows")]
{
return Err(crate::Error::FeatureDisabled {
name: "windows",
needed_for: "Windows theme detection",
});
}
#[cfg(target_os = "linux")]
{
return linux_fallback(
platform_preset_name(),
crate::detect::detect_is_dark(),
readerless_accessibility(),
);
}
#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
{
Err(crate::Error::PlatformUnsupported {
platform: std::env::consts::OS,
})
}
}
#[cfg(target_os = "linux")]
fn linux_fallback(
preset: PlatformPreset,
is_dark: bool,
accessibility: crate::AccessibilityPreferences,
) -> crate::Result<SystemTheme> {
let mode = if is_dark {
crate::ColorMode::Dark
} else {
crate::ColorMode::Light
};
let mut reader = preset_as_reader(preset.name, mode)?;
reader.accessibility = accessibility;
run_pipeline(reader, preset.name)
}
async fn read_through_pipeline(
reader: &dyn crate::reader::ThemeReader,
preset: &str,
detection: &crate::detect::DetectionContext,
) -> crate::Result<SystemTheme> {
let fill = detection.begin_reader_accessibility();
let result = reader.read().await?;
detection.store_reader_accessibility(fill, result.accessibility.clone());
run_pipeline(result, preset)
}
#[allow(unreachable_code)]
#[allow(clippy::needless_return)]
#[cfg_attr(
any(
all(target_os = "macos", not(feature = "macos")),
all(target_os = "windows", not(feature = "windows"))
),
allow(unused_variables)
)]
pub(crate) async fn from_system_with_preset_inner(preset: &str) -> crate::Result<SystemTheme> {
#[cfg(all(target_os = "macos", feature = "macos"))]
{
return pinned_pipeline(
&MACOS_GENERATIONS,
macos_major(crate::macos::os_version()),
preset,
&crate::macos::MacosReader,
crate::detect::system(),
)
.await;
}
#[cfg(all(target_os = "windows", feature = "windows"))]
{
return pinned_pipeline(
&WINDOWS_GENERATIONS,
crate::windows::os_version(),
preset,
&crate::windows::WindowsReader,
crate::detect::system(),
)
.await;
}
#[cfg(all(target_os = "macos", not(feature = "macos")))]
{
return Err(crate::Error::FeatureDisabled {
name: "macos",
needed_for: "macOS theme detection",
});
}
#[cfg(all(target_os = "windows", not(feature = "windows")))]
{
return Err(crate::Error::FeatureDisabled {
name: "windows",
needed_for: "Windows theme detection",
});
}
Err(crate::Error::UnknownPreset {
name: preset.to_string(),
known: &[],
})
}
#[cfg_attr(
not(any(
all(target_os = "macos", feature = "macos"),
all(target_os = "windows", feature = "windows")
)),
allow(dead_code)
)]
async fn pinned_pipeline(
table: &GenerationTable,
running: OsVersion,
preset: &str,
reader: &dyn crate::reader::ThemeReader,
detection: &crate::detect::DetectionContext,
) -> crate::Result<SystemTheme> {
let Some(row) = table.row(preset) else {
return Err(crate::Error::UnknownPreset {
name: preset.to_string(),
known: table.keys,
});
};
let mut theme = read_through_pipeline(reader, row.preset, detection).await?;
theme.version_match = Some(version_match(&row, running));
Ok(theme)
}
pub(crate) async fn reader_accessibility() -> crate::AccessibilityPreferences {
match select_reader().await {
Some(selected) => match selected.reader.read().await {
Ok(result) => result.accessibility,
Err(_) => readerless_accessibility(),
},
None => readerless_accessibility(),
}
}
fn readerless_accessibility() -> crate::AccessibilityPreferences {
crate::AccessibilityPreferences {
reduce_motion: crate::detect::detect_reduced_motion(),
..Default::default()
}
}
#[cfg(all(test, target_os = "linux"))]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod dispatch_tests {
use super::*;
#[test]
fn detect_kde_simple() {
assert_eq!(parse_linux_desktop("KDE"), LinuxDesktop::Kde);
}
#[test]
fn detect_kde_colon_separated_after() {
assert_eq!(parse_linux_desktop("ubuntu:KDE"), LinuxDesktop::Kde);
}
#[test]
fn detect_kde_colon_separated_before() {
assert_eq!(parse_linux_desktop("KDE:plasma"), LinuxDesktop::Kde);
}
#[test]
fn detect_gnome_simple() {
assert_eq!(parse_linux_desktop("GNOME"), LinuxDesktop::Gnome);
}
#[test]
fn detect_gnome_ubuntu() {
assert_eq!(parse_linux_desktop("ubuntu:GNOME"), LinuxDesktop::Gnome);
}
#[test]
fn detect_xfce() {
assert_eq!(parse_linux_desktop("XFCE"), LinuxDesktop::Xfce);
}
#[test]
fn detect_cinnamon() {
assert_eq!(parse_linux_desktop("X-Cinnamon"), LinuxDesktop::Cinnamon);
}
#[test]
fn detect_cinnamon_short() {
assert_eq!(parse_linux_desktop("Cinnamon"), LinuxDesktop::Cinnamon);
}
#[test]
fn detect_mate() {
assert_eq!(parse_linux_desktop("MATE"), LinuxDesktop::Mate);
}
#[test]
fn detect_lxqt() {
assert_eq!(parse_linux_desktop("LXQt"), LinuxDesktop::LxQt);
}
#[test]
fn detect_budgie() {
assert_eq!(parse_linux_desktop("Budgie:GNOME"), LinuxDesktop::Budgie);
}
#[test]
fn detect_empty_string() {
assert_eq!(parse_linux_desktop(""), LinuxDesktop::Unknown);
}
#[test]
fn from_linux_non_kde_returns_adwaita() -> crate::Result<()> {
let preset = linux_preset_for_de(LinuxDesktop::Gnome);
let result = preset_as_reader("adwaita", crate::ColorMode::Light)?;
let theme = run_pipeline(result, preset.name)?;
assert_eq!(theme.name, "Adwaita");
Ok(())
}
#[test]
#[cfg(feature = "kde")]
fn from_linux_unknown_de_with_kdeglobals_fallback() -> crate::Result<()> {
const MINIMAL_KDE_FIXTURE: &str = "\
[General]
ColorScheme=TestTheme
[Colors:Window]
BackgroundNormal=239,240,241
[Colors:View]
BackgroundNormal=252,252,252
ForegroundNormal=35,38,41
DecorationFocus=61,174,233
BackgroundAlternate=239,240,241
ForegroundLink=41,128,185";
let (reader_theme, dpi, acc) =
crate::kde::from_kde_content_pure(MINIMAL_KDE_FIXTURE, None)?;
let is_dark = reader_theme.dark.is_some() && reader_theme.light.is_none();
let output = if is_dark {
ReaderOutput::Single {
mode: Box::new(reader_theme.dark.unwrap_or_default()),
is_dark: true,
}
} else {
ReaderOutput::Single {
mode: Box::new(reader_theme.light.unwrap_or_default()),
is_dark: false,
}
};
let result = ReaderResult {
output,
name: reader_theme.name,
icon_set: reader_theme.icon_set,
layout: reader_theme.layout,
font_dpi: dpi,
accessibility: acc,
};
let preset = linux_preset_for_de(LinuxDesktop::Kde);
let theme = run_pipeline(result, preset.name)?;
assert_eq!(
theme.name, "TestTheme",
"should use KDE theme name from reader output"
);
Ok(())
}
#[test]
fn from_linux_unknown_de_without_kdeglobals_returns_adwaita() -> crate::Result<()> {
let preset = linux_preset_for_de(LinuxDesktop::Unknown);
let result = preset_as_reader("adwaita", crate::ColorMode::Light)?;
let theme = run_pipeline(result, preset.name)?;
assert_eq!(
theme.name, "Adwaita",
"should fall back to Adwaita without kdeglobals"
);
Ok(())
}
fn preset_theme(preset: &str) -> SystemTheme {
let theme = Theme::preset(preset).unwrap();
let reader = ReaderResult {
output: ReaderOutput::Dual {
light: Box::new(theme.light.unwrap_or_default()),
dark: Box::new(theme.dark.unwrap_or_default()),
is_dark: false,
},
name: theme.name,
icon_set: theme.icon_set,
layout: theme.layout,
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
run_pipeline(reader, preset).unwrap()
}
#[test]
fn the_fallback_on_kde_is_the_whole_breeze_preset() {
let expected = preset_theme("kde-breeze");
for is_dark in [false, true] {
let st = linux_fallback(
linux_preset_for_de(LinuxDesktop::Kde),
is_dark,
crate::AccessibilityPreferences::default(),
)
.unwrap();
assert_eq!(st.preset, "kde-breeze");
assert_eq!(st.name, expected.name, "is_dark {is_dark}");
assert_eq!(st.light, expected.light, "is_dark {is_dark}");
assert_eq!(st.dark, expected.dark, "is_dark {is_dark}");
assert_eq!(
st.icon_theme_for(crate::ColorMode::Light),
expected.icon_theme_for(crate::ColorMode::Light)
);
assert_eq!(
st.icon_theme_for(crate::ColorMode::Dark),
expected.icon_theme_for(crate::ColorMode::Dark)
);
}
}
#[test]
fn the_fallback_on_other_desktops_is_the_whole_adwaita_preset() {
let expected = preset_theme("adwaita");
let st = linux_fallback(
linux_preset_for_de(LinuxDesktop::Xfce),
true,
crate::AccessibilityPreferences::default(),
)
.unwrap();
assert_eq!(st.preset, "adwaita");
assert_eq!(st.name, expected.name);
assert_eq!(st.light, expected.light);
assert_eq!(st.dark, expected.dark);
}
#[test]
fn the_fallback_mode_is_the_dark_reading_it_is_given() {
let preset = || linux_preset_for_de(LinuxDesktop::Unknown);
let none = crate::AccessibilityPreferences::default;
assert_eq!(
linux_fallback(preset(), true, none()).unwrap().mode,
crate::ColorMode::Dark
);
assert_eq!(
linux_fallback(preset(), false, none()).unwrap().mode,
crate::ColorMode::Light
);
}
#[test]
fn the_fallback_carries_the_accessibility_it_is_given() {
let reduced = crate::AccessibilityPreferences {
reduce_motion: true,
..Default::default()
};
let st = linux_fallback(
linux_preset_for_de(LinuxDesktop::Xfce),
false,
reduced.clone(),
)
.unwrap();
assert_eq!(st.accessibility, reduced);
}
#[test]
fn an_unknown_desktop_with_kdeglobals_maps_to_breeze() {
let preset = |de, exists| {
linux_preset_for_de(crate::detect::refine_linux_desktop(de, None, || exists)).name
};
assert_eq!(preset(LinuxDesktop::Unknown, true), "kde-breeze");
assert_eq!(preset(LinuxDesktop::Unknown, false), "adwaita");
assert_eq!(preset(LinuxDesktop::Kde, false), "kde-breeze");
assert_eq!(preset(LinuxDesktop::Gnome, true), "adwaita");
assert_eq!(preset(LinuxDesktop::Xfce, true), "adwaita");
}
fn unknown_desktop_reader(
portal_backend: Option<LinuxDesktop>,
kdeglobals: bool,
) -> Option<LinuxReader> {
linux_reader_kind(crate::detect::refine_desktop(
LinuxDesktop::Unknown,
portal_backend,
|| kdeglobals,
))
}
#[test]
#[cfg(all(feature = "kde", feature = "portal"))]
fn an_unknown_desktop_with_a_kde_portal_gets_the_kde_reader() {
for kdeglobals in [false, true] {
assert_eq!(
unknown_desktop_reader(Some(LinuxDesktop::Kde), kdeglobals),
Some(LinuxReader::PortalKde)
);
}
assert_eq!(
linux_reader_kind(crate::detect::refine_desktop(
LinuxDesktop::Kde,
None,
|| false
)),
Some(LinuxReader::PortalKde)
);
}
#[test]
#[cfg(feature = "portal")]
fn an_unknown_desktop_with_a_gnome_portal_gets_the_gnome_reader() {
for kdeglobals in [false, true] {
assert_eq!(
unknown_desktop_reader(Some(LinuxDesktop::Gnome), kdeglobals),
Some(LinuxReader::Gnome)
);
}
}
#[test]
fn an_unknown_desktop_without_a_portal_answer() {
#[cfg(feature = "kde")]
assert_eq!(unknown_desktop_reader(None, true), Some(LinuxReader::Kde));
assert_eq!(unknown_desktop_reader(None, false), None);
}
#[test]
#[cfg(all(feature = "kde", feature = "portal"))]
fn the_linux_readers_presets() {
let preset = |portal_backend, kdeglobals| {
linux_reader(crate::detect::refine_desktop(
LinuxDesktop::Unknown,
portal_backend,
|| kdeglobals,
))
.map(|selected| selected.preset)
};
assert_eq!(preset(Some(LinuxDesktop::Kde), false), Some("kde-breeze"));
assert_eq!(preset(None, true), Some("kde-breeze"));
assert_eq!(preset(Some(LinuxDesktop::Gnome), true), Some("adwaita"));
}
#[test]
fn detect_hyprland() {
assert_eq!(parse_linux_desktop("Hyprland"), LinuxDesktop::Hyprland);
}
#[test]
fn detect_sway() {
assert_eq!(parse_linux_desktop("sway"), LinuxDesktop::Sway);
}
#[test]
fn detect_cosmic() {
assert_eq!(parse_linux_desktop("COSMIC"), LinuxDesktop::CosmicDe);
}
#[test]
fn detect_river() {
assert_eq!(parse_linux_desktop("river"), LinuxDesktop::River);
}
#[test]
fn detect_niri() {
assert_eq!(parse_linux_desktop("niri"), LinuxDesktop::Niri);
}
#[test]
fn parses_xdg_wayfire() {
assert_eq!(parse_linux_desktop("Wayfire"), LinuxDesktop::Wayfire);
assert_eq!(parse_linux_desktop("Wayfire:GNOME"), LinuxDesktop::Wayfire);
}
#[test]
fn parses_xdg_empty_is_unknown() {
assert_eq!(parse_linux_desktop(""), LinuxDesktop::Unknown);
}
#[test]
fn detect_cosmic_full_desktop() {
assert_eq!(
parse_linux_desktop("COSMIC:Freedesktop"),
LinuxDesktop::CosmicDe
);
}
#[test]
fn from_system_returns_result() {
let result = preset_as_reader("adwaita", crate::ColorMode::Light).unwrap();
let theme = run_pipeline(result, "adwaita")
.expect("run_pipeline should succeed with adwaita preset");
assert_eq!(theme.name, "Adwaita");
}
}
#[cfg(test)]
#[allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::field_reassign_with_default
)]
mod pipeline_tests {
use crate::color::Rgba;
use crate::model::{LayoutTheme, Theme, ThemeMode};
use crate::{ReaderOutput, ReaderResult};
use super::{preset_as_reader, read_through_pipeline, run_pipeline};
fn reader_from_preset(preset_name: &str) -> ReaderResult {
let preset = Theme::preset(preset_name).unwrap();
ReaderResult {
output: ReaderOutput::Dual {
light: Box::new(preset.light.clone().unwrap_or_default()),
dark: Box::new(preset.dark.clone().unwrap_or_default()),
is_dark: false,
},
name: preset.name,
icon_set: preset.icon_set,
layout: preset.layout,
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
}
}
#[test]
fn run_pipeline_rejects_a_bad_reader_font_dpi_once() {
for font_dpi in [0.0, -1.0, f32::NAN] {
let reader = ReaderResult {
font_dpi: Some(font_dpi),
..reader_from_preset("kde-breeze")
};
let result = run_pipeline(reader, "kde-breeze");
let Err(crate::Error::ResolutionInvalid { errors }) = result else {
panic!("font_dpi {font_dpi}: expected ResolutionInvalid");
};
let paths: Vec<&str> = errors.iter().map(|rv| rv.path.as_str()).collect();
assert_eq!(paths, ["context.font_dpi"], "font_dpi {font_dpi}");
}
}
#[test]
fn test_run_pipeline_produces_both_variants() {
let reader = reader_from_preset("catppuccin-mocha");
let result = run_pipeline(reader, "catppuccin-mocha");
assert!(result.is_ok(), "run_pipeline should succeed");
let st = result.unwrap();
assert!(!st.name.is_empty(), "name should be populated");
}
#[test]
fn test_run_pipeline_reader_values_win() {
let custom_accent = Rgba::rgb(42, 100, 200);
let mut variant = ThemeMode::default();
variant.defaults.accent_color = Some(custom_accent);
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(variant),
is_dark: false,
},
name: "CustomTheme".into(),
icon_set: None,
layout: LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let result = run_pipeline(reader, "catppuccin-mocha");
assert!(result.is_ok(), "run_pipeline should succeed");
let st = result.unwrap();
assert_eq!(
st.light.defaults.accent_color, custom_accent,
"reader accent should win over preset accent"
);
assert_eq!(st.name, "CustomTheme", "reader name should win");
}
#[test]
fn test_run_pipeline_single_variant() {
let full = Theme::preset("kde-breeze").unwrap();
let mut dark_v = full.dark.clone().unwrap();
dark_v.defaults.accent_color = Some(Rgba::rgb(200, 50, 50));
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(dark_v),
is_dark: true,
},
name: std::borrow::Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let result = run_pipeline(reader, "kde-breeze");
assert!(
result.is_ok(),
"run_pipeline should succeed with single variant"
);
let st = result.unwrap();
assert_eq!(
st.dark.defaults.accent_color,
Rgba::rgb(200, 50, 50),
"dark variant should have reader accent"
);
assert_eq!(st.preset, "kde-breeze");
}
#[test]
fn test_run_pipeline_inactive_variant_from_full_preset() {
let full = Theme::preset("kde-breeze").unwrap();
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(full.dark.clone().unwrap_or_default()),
is_dark: true,
},
name: std::borrow::Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let st = run_pipeline(reader, "kde-breeze").unwrap();
let full_light = full.light.unwrap();
assert_eq!(
st.light.defaults.accent_color,
full_light.defaults.accent_color.unwrap(),
"inactive light variant should get accent from full preset"
);
assert_eq!(
st.light.defaults.background_color,
full_light.defaults.background_color.unwrap(),
"inactive light variant should get background from full preset"
);
}
#[test]
fn test_run_pipeline_with_preset_as_reader() {
let reader = reader_from_preset("adwaita");
let result = run_pipeline(reader, "adwaita");
assert!(
result.is_ok(),
"double-merge with same preset should succeed"
);
let st = result.unwrap();
assert_eq!(st.name, "Adwaita");
}
#[test]
fn with_overlay_keeps_an_earlier_overlay() -> crate::Result<()> {
let st = run_pipeline(reader_from_preset("adwaita"), "adwaita")?;
let a = Theme::from_toml("[light.defaults]\naccent_color = \"#ff0000\"")?;
let b = Theme::from_toml("[light.defaults]\nbackground_color = \"#00ff00\"")?;
let both = st.with_overlay(&a)?.with_overlay(&b)?;
assert_eq!(both.light.defaults.accent_color, Rgba::rgb(255, 0, 0));
assert_eq!(both.light.defaults.background_color, Rgba::rgb(0, 255, 0));
let c = Theme::from_toml("[light.defaults]\naccent_color = \"#0000ff\"")?;
let all = both.with_overlay(&c)?;
assert_eq!(all.light.defaults.accent_color, Rgba::rgb(0, 0, 255));
assert_eq!(all.light.defaults.background_color, Rgba::rgb(0, 255, 0));
Ok(())
}
#[test]
fn test_single_variant_fills_inactive_from_preset() {
let full = Theme::preset("kde-breeze").unwrap();
let dark_v = full.dark.clone().unwrap();
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(dark_v),
is_dark: true,
},
name: "Breeze Dark".into(),
icon_set: full.icon_set,
layout: full.layout.clone(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let st = run_pipeline(reader, "kde-breeze").unwrap();
let full_light = Theme::preset("kde-breeze").unwrap().light.unwrap();
assert_eq!(
st.light.defaults.accent_color,
full_light.defaults.accent_color.unwrap(),
"Single: inactive light variant should come from full preset"
);
assert_eq!(st.mode, crate::ColorMode::Dark);
}
#[test]
fn test_dual_variant_uses_both_from_reader() {
let full = Theme::preset("macos-monterey").unwrap();
let custom_light_accent = Rgba::rgb(42, 100, 200);
let custom_dark_accent = Rgba::rgb(200, 50, 50);
let mut light_v = full.light.clone().unwrap();
light_v.defaults.accent_color = Some(custom_light_accent);
let mut dark_v = full.dark.clone().unwrap();
dark_v.defaults.accent_color = Some(custom_dark_accent);
let reader = ReaderResult {
output: ReaderOutput::Dual {
light: Box::new(light_v),
dark: Box::new(dark_v),
is_dark: false,
},
name: "macOS Sonoma".into(),
icon_set: full.icon_set,
layout: full.layout.clone(),
font_dpi: Some(72.0),
accessibility: crate::AccessibilityPreferences::default(),
};
let st = run_pipeline(reader, "macos-monterey").unwrap();
assert_eq!(
st.light.defaults.accent_color, custom_light_accent,
"Dual: light variant should have reader's light accent"
);
assert_eq!(
st.dark.defaults.accent_color, custom_dark_accent,
"Dual: dark variant should have reader's dark accent"
);
}
struct DarkDualReader;
#[async_trait::async_trait]
impl crate::reader::ThemeReader for DarkDualReader {
async fn read(&self) -> crate::Result<ReaderResult> {
let mut reader = reader_from_preset("macos-monterey");
if let ReaderOutput::Dual { is_dark, .. } = &mut reader.output {
*is_dark = true;
}
Ok(reader)
}
}
#[test]
fn dual_reader_mode_follows_is_dark() {
let detection = crate::detect::DetectionContext::new();
let st = pollster::block_on(read_through_pipeline(
&DarkDualReader,
"macos-monterey",
&detection,
))
.unwrap();
assert_eq!(
st.mode,
crate::ColorMode::Dark,
"a Dual reader reporting is_dark must give SystemTheme::mode Dark"
);
}
#[test]
fn a_pinned_older_generation_reports_preset_older() {
let detection = crate::detect::DetectionContext::new();
let st = pollster::block_on(super::pinned_pipeline(
&super::MACOS_GENERATIONS,
super::OsVersion::new(26, 0, 0),
"macos-monterey",
&DarkDualReader,
&detection,
))
.unwrap();
assert_eq!(st.preset, "macos-monterey");
assert_eq!(st.version_match, Some(super::VersionMatch::PresetOlder));
let overlaid = st
.with_overlay(&Theme::from_toml("name = \"overlay\"").unwrap())
.unwrap();
assert_eq!(overlaid.version_match, st.version_match);
}
#[test]
fn a_pinned_name_outside_the_table_is_unknown() {
let detection = crate::detect::DetectionContext::new();
let result = pollster::block_on(super::pinned_pipeline(
&super::MACOS_GENERATIONS,
super::OsVersion::new(26, 0, 0),
"kde-breeze",
&DarkDualReader,
&detection,
));
assert!(matches!(
result,
Err(crate::Error::UnknownPreset { known, .. }) if known == super::MACOS_GENERATIONS.keys
));
}
#[cfg(target_os = "linux")]
#[test]
fn linux_has_no_generation_to_pin() {
let result = pollster::block_on(super::from_system_with_preset_inner("adwaita"));
let err = result.err();
assert!(matches!(
err,
Some(crate::Error::UnknownPreset { known: [], .. })
));
assert!(
err.is_some_and(|e| e
.to_string()
.contains("no OS generations to choose between")),
"pinning a preset on Linux says the platform has no OS generations to choose between"
);
}
struct ScaledTextReader;
#[async_trait::async_trait]
impl crate::reader::ThemeReader for ScaledTextReader {
async fn read(&self) -> crate::Result<ReaderResult> {
let mut reader = reader_from_preset("adwaita");
reader.accessibility.text_scaling_factor = 1.5;
Ok(reader)
}
}
#[test]
fn the_system_read_fills_the_accessibility_cache() {
let detection = crate::detect::DetectionContext::new();
let st = pollster::block_on(read_through_pipeline(
&ScaledTextReader,
"adwaita",
&detection,
))
.unwrap();
let runs = std::cell::Cell::new(0);
let cached = detection.reader_accessibility_with(|| {
runs.set(runs.get() + 1);
crate::AccessibilityPreferences::default()
});
assert_eq!(runs.get(), 0, "the cache was empty after the system read");
assert_eq!(cached, st.accessibility);
assert_eq!(cached.text_scaling_factor, 1.5);
}
struct InvalidatedReader<'a>(&'a crate::detect::DetectionContext);
#[async_trait::async_trait]
impl crate::reader::ThemeReader for InvalidatedReader<'_> {
async fn read(&self) -> crate::Result<ReaderResult> {
self.0.invalidate_accessibility_preferences();
ScaledTextReader.read().await
}
}
#[test]
fn a_system_read_across_an_invalidation_leaves_the_cache_empty() {
let detection = crate::detect::DetectionContext::new();
pollster::block_on(read_through_pipeline(
&InvalidatedReader(&detection),
"adwaita",
&detection,
))
.unwrap();
let runs = std::cell::Cell::new(0);
let _ = detection.reader_accessibility_with(|| {
runs.set(runs.get() + 1);
crate::AccessibilityPreferences::default()
});
assert_eq!(
runs.get(),
1,
"a block read before the invalidation was cached"
);
}
fn reader_with_empty_variant(is_dark: bool) -> ReaderResult {
ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(ThemeMode::default()),
is_dark,
},
name: std::borrow::Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
}
}
#[test]
fn icon_theme_tier2_theme_level_used_when_per_variant_none() {
let reader = reader_with_empty_variant(false);
let st = run_pipeline(reader, "adwaita").unwrap();
assert_eq!(
st.icon_theme.as_deref(),
Some("Adwaita"),
"tier 2: Theme.icon_theme should be used when per-variant is None"
);
}
#[test]
fn icon_theme_tier1_per_variant_wins_over_theme_level() {
let mut variant = ThemeMode::default();
variant.defaults.icon_theme = Some(std::borrow::Cow::Borrowed("custom-override"));
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(variant),
is_dark: false,
},
name: std::borrow::Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let st = run_pipeline(reader, "adwaita").unwrap();
assert_eq!(
st.icon_theme.as_deref(),
Some("custom-override"),
"tier 1: per-variant icon_theme override must win over Theme-level"
);
}
#[test]
fn with_overlay_applies_the_overlays_icon_theme_and_layout() -> crate::Result<()> {
let st = run_pipeline(reader_from_preset("adwaita"), "adwaita")?;
let kept = st.with_overlay(&Theme::default())?;
assert_eq!(kept.icon_theme, st.icon_theme);
assert_eq!(kept.layout.widget_gap, st.layout.widget_gap);
let overlay =
Theme::from_toml("icon_theme = \"custom-override\"\n[layout]\nwidget_gap_px = 9.0")?;
let changed = st.with_overlay(&overlay)?;
assert_eq!(changed.icon_theme.as_deref(), Some("custom-override"));
assert_eq!(
changed.icon_theme_for(crate::ColorMode::Dark),
Some("custom-override")
);
assert_eq!(changed.layout.widget_gap, Some(9.0));
Ok(())
}
#[test]
fn icon_theme_kde_per_variant_values_still_win() {
let kde_full = Theme::preset("kde-breeze").unwrap();
let dark_v = kde_full.dark.clone().unwrap();
assert_eq!(
dark_v.defaults.icon_theme.as_deref(),
Some("breeze-dark"),
"precondition: kde-breeze dark variant must carry breeze-dark"
);
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(dark_v),
is_dark: true,
},
name: std::borrow::Cow::Borrowed(""),
icon_set: None,
layout: LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let st = run_pipeline(reader, "kde-breeze").unwrap();
assert_eq!(
st.icon_theme.as_deref(),
Some("breeze-dark"),
"KDE per-variant icon_theme must still win (Phase 80-fix invariant)"
);
}
#[test]
fn theme_icon_theme_round_trips_when_some() {
let theme = Theme {
name: std::borrow::Cow::Borrowed("RoundTrip"),
light: Some(ThemeMode::default()),
dark: None,
layout: LayoutTheme::default(),
icon_set: None,
icon_theme: Some(std::borrow::Cow::Borrowed("lucide")),
};
let toml_str = theme.to_toml().expect("serialize");
let reparsed = Theme::from_toml(&toml_str).expect("deserialize");
assert_eq!(
reparsed.icon_theme.as_deref(),
Some("lucide"),
"Theme.icon_theme must round-trip through TOML"
);
assert!(
toml_str.contains("icon_theme = \"lucide\""),
"serialized TOML should contain top-level icon_theme, got:\n{toml_str}"
);
}
#[test]
fn theme_icon_theme_skipped_when_none() {
let theme = Theme {
name: std::borrow::Cow::Borrowed("NoIcon"),
light: Some(ThemeMode::default()),
dark: None,
layout: LayoutTheme::default(),
icon_set: None,
icon_theme: None,
};
let toml_str = theme.to_toml().expect("serialize");
assert!(
!toml_str.contains("icon_theme"),
"serialized TOML should NOT contain icon_theme when None, got:\n{toml_str}"
);
}
#[test]
fn lint_toml_accepts_top_level_icon_theme() {
let toml_str = r##"
name = "Test"
icon_theme = "lucide"
[light.defaults]
accent_color = "#0066cc"
"##;
let warnings = Theme::lint_toml(toml_str).expect("lint");
assert!(
!warnings.iter().any(|w| w.contains("icon_theme")),
"lint_toml must not flag top-level icon_theme as unknown; warnings: {warnings:?}"
);
}
#[test]
fn system_theme_layout_is_the_merged_preset_layout() -> crate::Result<()> {
let reader = preset_as_reader("adwaita", crate::ColorMode::Light)?;
let sys = run_pipeline(reader, "adwaita")?;
let mut expected = Theme::preset("adwaita")?.layout;
expected.merge(&Theme::preset("adwaita")?.layout);
assert_eq!(sys.layout, expected);
assert!(
sys.layout.widget_gap.is_some(),
"adwaita defines all four layout keys (spec §1.3)"
);
Ok(())
}
#[test]
fn system_theme_layout_out_of_range_is_invalid() -> crate::Result<()> {
let mut reader = preset_as_reader("adwaita", crate::ColorMode::Light)?;
reader.layout.widget_gap = Some(-8.0);
let Err(crate::Error::ResolutionInvalid { errors }) = run_pipeline(reader, "adwaita")
else {
panic!("expected ResolutionInvalid");
};
let paths: Vec<&str> = errors.iter().map(|rv| rv.path.as_str()).collect();
assert_eq!(paths, ["layout.widget_gap_px"]);
let reader = preset_as_reader("adwaita", crate::ColorMode::Light)?;
let mut sys = run_pipeline(reader, "adwaita")?;
sys.overlay_source.layout.section_gap = Some(f32::NAN);
let Err(crate::Error::ResolutionInvalid { errors }) = sys.with_overlay(&Theme::default())
else {
panic!("expected ResolutionInvalid");
};
let paths: Vec<&str> = errors.iter().map(|rv| rv.path.as_str()).collect();
assert_eq!(paths, ["layout.section_gap_px"]);
Ok(())
}
#[test]
fn icon_loads_from_the_modes_icon_theme() -> crate::Result<()> {
let mut theme = run_pipeline(reader_from_preset("kde-breeze"), "kde-breeze")?;
for active in [crate::ColorMode::Light, crate::ColorMode::Dark] {
theme.mode = active;
for (mode, expected) in [
(crate::ColorMode::Light, "breeze"),
(crate::ColorMode::Dark, "breeze-dark"),
] {
let source =
theme.with_icon_source(mode, |set, theme| (set, theme.map(str::to_owned)));
assert_eq!(
source,
(crate::IconSet::Freedesktop, Some(expected.to_owned())),
"kde-breeze.toml:16 and :601 (active mode {active:?}, asked {mode:?})"
);
assert_eq!(theme.icon_theme_for(mode), Some(expected));
}
}
Ok(())
}
#[test]
#[cfg(all(target_os = "linux", feature = "system-icons"))]
fn icon_and_indicator_load_from_the_modes_freedesktop_theme() -> crate::Result<()> {
use crate::icons::{FreedesktopLoader, IconRole, is_freedesktop_theme_available};
const MISSING: &str = "native-theme-no-such-theme";
assert!(!is_freedesktop_theme_available(MISSING));
let mut theme = run_pipeline(reader_from_preset("kde-breeze"), "kde-breeze")?;
theme.light_icon_theme = Some(std::borrow::Cow::Borrowed(MISSING));
let role = IconRole::ActionCopy;
for active in [crate::ColorMode::Light, crate::ColorMode::Dark] {
theme.mode = active;
assert_eq!(
theme.icon(role, crate::ColorMode::Light, None),
None,
"light icon from {MISSING} (active mode {active:?})"
);
assert_eq!(
theme.icon_indicator(crate::ColorMode::Light),
None,
"light spinner from {MISSING} (active mode {active:?})"
);
assert_eq!(
theme.icon(role, crate::ColorMode::Dark, None),
FreedesktopLoader::new(role).theme("breeze-dark").load(),
"dark icon from breeze-dark, kde-breeze.toml:601 (active mode {active:?})"
);
assert_eq!(
theme.icon_indicator(crate::ColorMode::Dark),
FreedesktopLoader::load_indicator(Some("breeze-dark")),
"dark spinner from breeze-dark (active mode {active:?})"
);
}
Ok(())
}
#[test]
#[cfg(feature = "material-icons")]
fn icon_of_a_material_theme_comes_back_in_the_colour() -> crate::Result<()> {
let theme = run_pipeline(reader_from_preset("material-3"), "material-3")?;
assert_eq!(
theme.icon_set,
crate::IconSet::Material,
"material-3.toml:9"
);
let color = Rgba::rgb(0x12, 0x34, 0x56);
for mode in [crate::ColorMode::Light, crate::ColorMode::Dark] {
match theme.icon(crate::IconRole::ActionCopy, mode, Some(color)) {
Some(crate::IconData::Svg(svg)) => {
let svg = String::from_utf8(svg.into_owned()).unwrap();
assert!(svg.contains("#123456"), "{mode:?}: {svg}");
}
other => panic!("expected an SVG for {mode:?}, got {other:?}"),
}
assert!(
theme.icon_indicator(mode).is_some(),
"Material's spinner ({mode:?})"
);
}
Ok(())
}
#[test]
fn icon_theme_for_gives_each_variants_name() -> crate::Result<()> {
for mode in [crate::ColorMode::Light, crate::ColorMode::Dark] {
let reader = ReaderResult {
output: ReaderOutput::Single {
mode: Box::new(crate::model::ThemeMode::default()),
is_dark: mode == crate::ColorMode::Dark,
},
name: std::borrow::Cow::Borrowed(""),
icon_set: None,
layout: crate::theme::LayoutTheme::default(),
font_dpi: None,
accessibility: crate::AccessibilityPreferences::default(),
};
let theme = run_pipeline(reader, "kde-breeze")?;
assert_eq!(
theme.icon_theme_for(crate::ColorMode::Light),
Some("breeze"),
"kde-breeze.toml:16 names breeze for light (active mode {mode:?})"
);
assert_eq!(
theme.icon_theme_for(crate::ColorMode::Dark),
Some("breeze-dark"),
"kde-breeze.toml:601 names breeze-dark for dark (active mode {mode:?})"
);
assert_eq!(
theme.icon_theme_for(mode),
theme.icon_theme.as_deref(),
"the active mode's name is `icon_theme` itself"
);
let mut flipped = theme;
flipped.mode = match mode {
crate::ColorMode::Light => crate::ColorMode::Dark,
crate::ColorMode::Dark => crate::ColorMode::Light,
};
assert_eq!(
flipped.icon_theme_for(crate::ColorMode::Light),
Some("breeze"),
"built in {mode:?}, mode flipped"
);
assert_eq!(
flipped.icon_theme_for(crate::ColorMode::Dark),
Some("breeze-dark"),
"built in {mode:?}, mode flipped"
);
}
Ok(())
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod theme_reader_trait_tests {
#[test]
fn theme_reader_trait_exists_and_is_object_safe() {
#[allow(dead_code)]
fn assert_object_safe<T: ?Sized>(_: &T) {}
#[cfg(all(target_os = "linux", feature = "kde"))]
{
let r: Box<dyn crate::reader::ThemeReader> = Box::new(crate::kde::KdeReader);
assert_object_safe(&r);
}
#[cfg(all(target_os = "macos", feature = "macos"))]
{
let r: Box<dyn crate::reader::ThemeReader> = Box::new(crate::macos::MacosReader);
assert_object_safe(&r);
}
#[cfg(all(target_os = "windows", feature = "windows"))]
{
let r: Box<dyn crate::reader::ThemeReader> = Box::new(crate::windows::WindowsReader);
assert_object_safe(&r);
}
let _: Option<&dyn crate::reader::ThemeReader> = None;
}
#[test]
fn select_reader_returns_platform_specific_impl() {
let picked: Option<super::SelectedReader> = pollster::block_on(super::select_reader());
#[cfg(all(target_os = "macos", feature = "macos"))]
{
assert!(
picked.is_some(),
"select_reader must return Some on macOS+macos"
);
if let Some(selected) = &picked {
let (preset, matched) = super::macos_generation(crate::macos::os_version());
assert_eq!(selected.preset, preset.name);
assert_eq!(selected.version_match, Some(matched));
}
}
#[cfg(all(target_os = "windows", feature = "windows"))]
{
assert!(
picked.is_some(),
"select_reader must return Some on windows+windows"
);
if let Some(selected) = &picked {
let (preset, matched) = super::windows_generation(crate::windows::os_version());
assert_eq!(selected.preset, preset.name);
assert_eq!(selected.version_match, Some(matched));
}
}
#[cfg(all(target_os = "linux", feature = "kde", feature = "portal"))]
{
if let Some(selected) = &picked {
assert!(
selected.preset == "kde-breeze" || selected.preset == "adwaita",
"select_reader on linux must return a known platform preset, got: {}",
selected.preset
);
assert_eq!(selected.version_match, None);
}
}
#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
{
assert!(
picked.is_none(),
"select_reader() must return None on unsupported platforms"
);
}
drop(picked);
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod generation_tests {
use super::*;
fn macos_preset_for_version(major: u32) -> &'static str {
macos_generation(OsVersion::new(major, 0, 0)).0.name
}
#[test]
fn macos_preset_follows_the_os_generation() {
assert_eq!(macos_preset_for_version(12), "macos-monterey");
assert_eq!(macos_preset_for_version(14), "macos-monterey");
assert_eq!(macos_preset_for_version(15), "macos-monterey");
assert_eq!(macos_preset_for_version(26), "macos-tahoe");
assert_eq!(macos_preset_for_version(27), "macos-tahoe");
assert_eq!(
macos_generation(OsVersion::new(27, 0, 1)).1,
VersionMatch::PresetOlder
);
assert_eq!(
macos_generation(OsVersion::new(16, 0, 0)),
(
PlatformPreset {
name: "macos-monterey"
},
VersionMatch::PresetOlder
)
);
assert_eq!(
macos_generation(OsVersion::new(0, 0, 0)),
(
PlatformPreset {
name: "macos-monterey"
},
VersionMatch::PresetNewer
)
);
}
#[test]
fn macos_versions_inside_a_generation_match_exactly() {
for v in [
OsVersion::new(12, 0, 0),
OsVersion::new(14, 8, 9),
OsVersion::new(15, 7, 9),
OsVersion::new(26, 6, 2),
] {
assert_eq!(macos_generation(v).1, VersionMatch::Exact, "{v}");
}
assert_eq!(
macos_generation(OsVersion::new(11, 7, 10)),
(
PlatformPreset {
name: "macos-monterey"
},
VersionMatch::PresetNewer
)
);
}
#[test]
fn windows_preset_follows_the_build() {
assert_eq!(
windows_generation(OsVersion::new(10, 0, 19045)),
(
PlatformPreset { name: "windows-11" },
VersionMatch::PresetNewer
)
);
assert_eq!(
windows_generation(OsVersion::new(10, 0, 22000)).1,
VersionMatch::Exact
);
assert_eq!(
windows_generation(OsVersion::new(10, 0, 26200)).1,
VersionMatch::Exact
);
assert_eq!(
windows_generation(OsVersion::new(10, 0, 26300)).1,
VersionMatch::PresetOlder
);
assert_eq!(
windows_generation(OsVersion::new(10, 0, 28000)),
(
PlatformPreset { name: "windows-11" },
VersionMatch::PresetOlder
)
);
assert_eq!(
windows_generation(OsVersion::new(0, 0, 0)),
(
PlatformPreset { name: "windows-11" },
VersionMatch::PresetNewer
)
);
}
#[test]
fn every_table_is_ordered_and_lists_its_keys() {
for table in [MACOS_GENERATIONS, WINDOWS_GENERATIONS] {
let rows: Vec<Generation> = table.rows().collect();
let keys: Vec<&str> = rows.iter().map(|g| g.preset).collect();
assert_eq!(keys, table.keys);
for g in &rows {
assert!(g.first <= g.last_verified, "{}", g.preset);
}
for (older, newer) in rows.iter().zip(rows.iter().skip(1)) {
assert!(
older.last_verified < newer.first,
"{} / {}",
older.preset,
newer.preset
);
}
}
}
#[test]
fn every_generation_is_a_bundled_preset_of_its_platform() {
for (table, platform) in [
(MACOS_GENERATIONS, "macos"),
(WINDOWS_GENERATIONS, "windows"),
] {
for key in table.keys {
assert!(crate::Theme::preset(key).is_ok(), "{key}");
let offered = crate::Theme::list_presets()
.iter()
.any(|p| p.key == *key && p.platforms.contains(&platform));
assert!(offered, "{key} is not offered on {platform}");
}
}
}
#[test]
fn the_diagnostic_names_the_version_and_its_preset() {
let entry = DiagnosticEntry::OsGeneration {
version: OsVersion::new(27, 0, 1).to_string(),
preset: "macos-tahoe",
version_match: VersionMatch::PresetOlder,
};
assert_eq!(entry.name(), "OS version");
assert_eq!(entry.status(), "27.0.1");
assert_eq!(
entry.to_string(),
"OS version: 27.0.1 (macos-tahoe, preset older than the OS)"
);
}
}