First commit. Version 0.1.0

2026-05-10 09:58:23 +02:00
parent af105b7f7d
commit bbab5e238d
635 changed files with 53627 additions and 175 deletions
--- a/tests/theme_parsing.rs
+++ b/tests/theme_parsing.rs
@@ -0,0 +1,399 @@
+use std::path::PathBuf;
+use std::sync::Mutex;
+use std::sync::atomic::{ AtomicU32, Ordering };
+
+use ltk::{ ThemeDocument, ThemeMode, WallpaperFit };
+
+/// Serialises tests that mutate the process-global active theme state
+/// (`set_active_mode`, `theme_wallpaper`, …). `cargo test` runs tests
+/// in parallel by default; without this guard a Light test can read
+/// Dark state set by a concurrent test mid-flight.
+static THEME_STATE_LOCK: Mutex<()> = Mutex::new( () );
+
+// ── Per-test temp dir ─────────────────────────────────────────────────────────
+
+/// Build a unique temp dir per test invocation. `process::id()` alone is not
+/// enough — `cargo test` runs tests in the same process so a stale dir from a
+/// previous test in the same run would collide. Add a process-local counter.
+fn fresh_temp_dir( tag: &str ) -> PathBuf
+{
+	static COUNTER: AtomicU32 = AtomicU32::new( 0 );
+	let n   = COUNTER.fetch_add( 1, Ordering::SeqCst );
+	let dir = std::env::temp_dir()
+		.join( format!( "ltk-theme-test-{}-{}-{}", std::process::id(), tag, n ) );
+	let _ = std::fs::remove_dir_all( &dir );
+	std::fs::create_dir_all( &dir ).unwrap();
+	dir
+}
+
+const MINIMAL_THEME_JSON: &str = r##"
+{
+	"theme": { "id": "demo", "name": "Demo" },
+	"fonts": {
+		"sora": { "name": "Sora", "fallbacks": [], "sources": [] }
+	},
+	"modes": {
+		"light": {
+			"wallpaper":       { "path": "wp/light.jpg",      "fit": "cover"   },
+			"lockscreen":      { "path": "wp/lock-light.jpg", "fit": "cover"   },
+			"launcher":        { "background": "#FFFFFFE6", "border_radius": 24.0 },
+			"window_controls": {
+				"icon":           "#112233",
+				"hover_bg":       "#11223322",
+				"pressed_bg":     "#11223333",
+				"close_hover_bg": "#AA0000",
+				"close_icon":     "#FFFFFF",
+				"focus_ring":     "#00CEB1"
+			},
+			"slots": {
+				"bg-page":        { "type": "color", "value": "#FFFFFF"   },
+				"surface":        { "type": "color", "value": "#FFFFFF99" },
+				"surface-alt":    { "type": "color", "value": "#FFFFFFD9" },
+				"text-primary":   { "type": "color", "value": "#102030"   },
+				"text-secondary": { "type": "color", "value": "#10203080" },
+				"accent":         { "type": "color", "value": "#00CEB1"   },
+				"divider":        { "type": "color", "value": "#00000014" },
+				"icon":           { "type": "color", "value": "#000000"   }
+			}
+		},
+		"dark": {
+			"wallpaper":       { "path": "wp/dark.jpg",      "fit": "contain" },
+			"lockscreen":      { "path": "wp/lock-dark.jpg", "fit": "cover"   },
+			"launcher":        { "background": "#221A5AE6", "border_radius": 24.0 },
+			"window_controls": {
+				"icon":           "#EEEEEE",
+				"hover_bg":       "#FFFFFF18",
+				"pressed_bg":     "#FFFFFF26",
+				"close_hover_bg": "#E5484D",
+				"close_icon":     "#FFFFFF",
+				"focus_ring":     "#00CEB1"
+			},
+			"slots": {
+				"bg-page":        { "type": "color", "value": "#000000"   },
+				"surface":        { "type": "color", "value": "#18104599" },
+				"surface-alt":    { "type": "color", "value": "#221A5AD9" },
+				"text-primary":   { "type": "color", "value": "#FFFFFF"   },
+				"text-secondary": { "type": "color", "value": "#FFFFFFB3" },
+				"accent":         { "type": "color", "value": "#00CEB1"   },
+				"divider":        { "type": "color", "value": "#FFFFFF14" },
+				"icon":           { "type": "color", "value": "#FFFFFF"   }
+			}
+		}
+	}
+}
+"##;
+
+// ── Round-trip ────────────────────────────────────────────────────────────────
+
+#[ test ]
+fn parses_id_name_and_both_modes()
+{
+	let dir = fresh_temp_dir( "round-trip" );
+	std::fs::write( dir.join( "theme.json" ), MINIMAL_THEME_JSON ).unwrap();
+
+	let doc = ThemeDocument::load_from_dir( &dir ).expect( "minimal theme should parse" );
+	assert_eq!( doc.id,   "demo" );
+	assert_eq!( doc.name, "Demo" );
+
+	// Wallpaper fit fields round-trip through the enum.
+	assert_eq!( doc.light.wallpaper.as_ref().unwrap().fit, WallpaperFit::Cover );
+	assert_eq!( doc.dark.wallpaper.as_ref().unwrap().fit,  WallpaperFit::Contain );
+
+	let _ = std::fs::remove_dir_all( &dir );
+}
+
+#[ test ]
+fn palette_hex_strings_round_trip_through_slots()
+{
+	let dir = fresh_temp_dir( "palette" );
+	std::fs::write( dir.join( "theme.json" ), MINIMAL_THEME_JSON ).unwrap();
+	let doc = ThemeDocument::load_from_dir( &dir ).unwrap();
+
+	// "#102030" → R=0x10/255, G=0x20/255, B=0x30/255, A=1.0
+	let p = doc.light.slots.color( "text-primary" ).expect( "text-primary slot" );
+	let expected = ( 0x10 as f32 / 255.0, 0x20 as f32 / 255.0, 0x30 as f32 / 255.0 );
+	assert!( ( p.r - expected.0 ).abs() < 1e-3, "r={}, expected {}", p.r, expected.0 );
+	assert!( ( p.g - expected.1 ).abs() < 1e-3, "g={}, expected {}", p.g, expected.1 );
+	assert!( ( p.b - expected.2 ).abs() < 1e-3, "b={}, expected {}", p.b, expected.2 );
+	assert!( ( p.a - 1.0 ).abs() < 1e-3,        "a={}, expected 1.0", p.a );
+
+	// 8-digit hex with alpha: "#10203080" → A ≈ 0x80/255
+	let s = doc.light.slots.color( "text-secondary" ).unwrap();
+	assert!( ( s.a - ( 0x80 as f32 / 255.0 ) ).abs() < 1e-3 );
+
+	let _ = std::fs::remove_dir_all( &dir );
+}
+
+#[ test ]
+fn window_control_tokens_round_trip()
+{
+	let dir = fresh_temp_dir( "window-controls" );
+	std::fs::write( dir.join( "theme.json" ), MINIMAL_THEME_JSON ).unwrap();
+	let doc = ThemeDocument::load_from_dir( &dir ).unwrap();
+
+	let wc = doc.light.window_controls.as_ref().expect( "window_controls" );
+	assert!( ( wc.icon.r - ( 0x11 as f32 / 255.0 ) ).abs() < 1e-3 );
+	assert!( ( wc.icon.g - ( 0x22 as f32 / 255.0 ) ).abs() < 1e-3 );
+	assert!( ( wc.icon.b - ( 0x33 as f32 / 255.0 ) ).abs() < 1e-3 );
+	assert!( ( wc.icon.a - 1.0 ).abs() < 1e-3 );
+
+	assert!( ( wc.hover_bg.a - ( 0x22 as f32 / 255.0 ) ).abs() < 1e-3 );
+
+	let _ = std::fs::remove_dir_all( &dir );
+}
+
+#[ test ]
+fn relative_asset_paths_resolve_against_theme_dir()
+{
+	let dir = fresh_temp_dir( "paths" );
+	std::fs::write( dir.join( "theme.json" ), MINIMAL_THEME_JSON ).unwrap();
+	let doc = ThemeDocument::load_from_dir( &dir ).unwrap();
+
+	let wp = doc.light.wallpaper.as_ref().unwrap().path.as_ref().expect( "wallpaper path" );
+	assert_eq!( wp, &dir.join( "wp/light.jpg" ) );
+
+	let lock = doc.dark.lockscreen.as_ref().unwrap().path.as_ref().expect( "lockscreen path" );
+	assert_eq!( lock, &dir.join( "wp/lock-dark.jpg" ) );
+
+	let _ = std::fs::remove_dir_all( &dir );
+}
+
+// ── Errors ────────────────────────────────────────────────────────────────────
+
+#[ test ]
+fn missing_theme_json_returns_error()
+{
+	// Empty dir — load_from_dir should fail rather than panic.
+	let dir = fresh_temp_dir( "missing" );
+	let result = ThemeDocument::load_from_dir( &dir );
+	assert!( result.is_err(), "expected Err for empty dir" );
+	let _ = std::fs::remove_dir_all( &dir );
+}
+
+// ── Mode resolution ───────────────────────────────────────────────────────────
+
+/// Point `LTK_THEMES_DIR` at the in-tree `themes/` so any test that
+/// triggers `ensure_active` finds the bundled `default` theme without
+/// requiring a system install. Sets the env var unconditionally — the
+/// global `ACTIVE` is process-wide so the first test that calls
+/// `ensure_active` wins, and a stale env var from a prior run would
+/// just point at the same directory.
+fn point_at_in_tree_themes()
+{
+	std::env::set_var
+	(
+		"LTK_THEMES_DIR",
+		env!( "CARGO_MANIFEST_DIR" ).to_string() + "/themes",
+	);
+}
+
+#[ test ]
+fn theme_mode_round_trip()
+{
+	// Switching the active mode at runtime is observable via
+	// `ltk::active_mode()`. This triggers `ensure_active()` which loads
+	// the in-tree default theme.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	ltk::set_active_mode( ThemeMode::Light );
+	assert_eq!( ltk::active_mode(), ThemeMode::Light );
+	ltk::set_active_mode( ThemeMode::Dark );
+	assert_eq!( ltk::active_mode(), ThemeMode::Dark );
+}
+
+#[ test ]
+fn theme_wallpaper_resolves_for_active_mode()
+{
+	// `theme_wallpaper()` resolves via the convention
+	// `branding/{mode}/wallpaper.svg` (the default theme no longer
+	// declares an explicit `wallpaper.path` in theme.json), with the
+	// standard mode → opposite-mode → no-mode fallback chain.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	ltk::set_active_mode( ThemeMode::Light );
+	let wp = ltk::theme_wallpaper().expect( "Light resolves via branding/light/" );
+	let path = wp.path.expect( "convention resolution returns a concrete path" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/light/wallpaper.svg" ),
+		"unexpected Light wallpaper path: {}", path.display(),
+	);
+
+	ltk::set_active_mode( ThemeMode::Dark );
+	let wp = ltk::theme_wallpaper().expect( "Dark resolves via branding/dark/" );
+	let path = wp.path.expect( "convention resolution returns a concrete path" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/dark/wallpaper.svg" ),
+		"unexpected Dark wallpaper path: {}", path.display(),
+	);
+}
+
+#[ test ]
+fn theme_lockscreen_resolves_for_active_mode()
+{
+	// `theme_lockscreen()` mirrors `theme_wallpaper()` against the
+	// convention `branding/{mode}/lockscreen.svg`. The default theme
+	// ships both Light and Dark variants, so each mode resolves to its
+	// own asset without needing the fallback chain.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	ltk::set_active_mode( ThemeMode::Light );
+	let ls = ltk::theme_lockscreen().expect( "Light resolves via branding/light/" );
+	let path = ls.path.expect( "convention resolution returns a concrete path" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/light/lockscreen.svg" ),
+		"unexpected Light lockscreen path: {}", path.display(),
+	);
+
+	ltk::set_active_mode( ThemeMode::Dark );
+	let ls = ltk::theme_lockscreen().expect( "Dark resolves via branding/dark/" );
+	let path = ls.path.expect( "convention resolution returns a concrete path" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/dark/lockscreen.svg" ),
+		"unexpected Dark lockscreen path: {}", path.display(),
+	);
+}
+
+#[ test ]
+fn theme_logo_variants_resolve_for_active_mode()
+{
+	// `theme_logo`, `theme_logo_square`, `theme_logo_horizontal` are
+	// thin wrappers over `branding_asset( "logo/<variant>", "svg" )`.
+	// The default theme ships all three SVG variants for both modes
+	// under `branding/{mode}/logo/`, so each call resolves directly
+	// to its own-mode file without the cross-mode fallback.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	for mode in [ ThemeMode::Light, ThemeMode::Dark ]
+	{
+		ltk::set_active_mode( mode );
+		let mode_dir = match mode
+		{
+			ThemeMode::Light => "branding/light/logo/",
+			ThemeMode::Dark  => "branding/dark/logo/",
+		};
+
+		let primary = ltk::theme_logo()
+			.unwrap_or_else( || panic!( "theme_logo missing for {mode:?}" ) );
+		assert!
+		(
+			primary.to_string_lossy().ends_with( &format!( "{mode_dir}logo.svg" ) ),
+			"unexpected {mode:?} logo path: {}", primary.display(),
+		);
+
+		let square = ltk::theme_logo_square()
+			.unwrap_or_else( || panic!( "theme_logo_square missing for {mode:?}" ) );
+		assert!
+		(
+			square.to_string_lossy().ends_with( &format!( "{mode_dir}square.svg" ) ),
+			"unexpected {mode:?} square logo path: {}", square.display(),
+		);
+
+		let horizontal = ltk::theme_logo_horizontal()
+			.unwrap_or_else( || panic!( "theme_logo_horizontal missing for {mode:?}" ) );
+		assert!
+		(
+			horizontal.to_string_lossy().ends_with( &format!( "{mode_dir}horizontal.svg" ) ),
+			"unexpected {mode:?} horizontal logo path: {}", horizontal.display(),
+		);
+	}
+}
+
+#[ test ]
+fn branding_raster_picks_smallest_covering_at_each_target_size()
+{
+	// The default theme ships `1280x720`, `1920x1080`, `3840x2160` WebPs
+	// for both wallpaper and lockscreen in both modes. The lookup must
+	// pick the smallest entry whose two dimensions cover the surface.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	ltk::set_active_mode( ThemeMode::Light );
+
+	// Surface ≤ 720p → 1280x720 covers it.
+	let path = ltk::theme_branding_raster( "wallpaper", 800, 600 )
+		.expect( "Light raster covers 800x600" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/light/wallpaper/1280x720.webp" ),
+		"unexpected raster for 800x600: {}", path.display(),
+	);
+
+	// Surface 1080p exact → 1920x1080 covers it.
+	let path = ltk::theme_branding_raster( "wallpaper", 1920, 1080 )
+		.expect( "Light raster covers 1920x1080" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/light/wallpaper/1920x1080.webp" ),
+		"unexpected raster for 1920x1080: {}", path.display(),
+	);
+
+	// 1920x1200 (16:10 laptop) → 1080 < 1200, so 1080p is too short. Next
+	// up that covers both axes is 4K.
+	let path = ltk::theme_branding_raster( "wallpaper", 1920, 1200 )
+		.expect( "Light raster covers 1920x1200" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/light/wallpaper/3840x2160.webp" ),
+		"unexpected raster for 1920x1200: {}", path.display(),
+	);
+}
+
+#[ test ]
+fn branding_raster_falls_back_to_largest_when_none_covers()
+{
+	// 5000-wide surface exceeds the largest shipped raster (3840). No
+	// covering candidate, so the lookup falls back to the largest
+	// available raster — a fast-decoding upscaled WebP beats paying the
+	// SVG rasterisation cost.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	ltk::set_active_mode( ThemeMode::Dark );
+
+	let path = ltk::theme_branding_raster( "wallpaper", 5000, 3000 )
+		.expect( "no covering raster but the largest is returned" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/dark/wallpaper/3840x2160.webp" ),
+		"unexpected fallback raster for 5000x3000: {}", path.display(),
+	);
+
+	// `branding_image` returns the same — it only falls to the SVG when
+	// no raster files exist at all.
+	let img = ltk::theme_branding_image( "wallpaper", 5000, 3000 )
+		.expect( "branding_image returns the same largest raster" );
+	assert_eq!( img, path );
+}
+
+#[ test ]
+fn branding_raster_with_zero_size_returns_smallest_available()
+{
+	// (0, 0) means "surface size unknown — give me the smallest variant".
+	// Every entry trivially covers a 0×0 surface so the smallest by area
+	// wins. Used at startup so the first frame paints a fast-decoded
+	// lightweight raster instead of paying the SVG rasterisation cost.
+	let _guard = THEME_STATE_LOCK.lock().unwrap_or_else( |p| p.into_inner() );
+	point_at_in_tree_themes();
+
+	ltk::set_active_mode( ThemeMode::Light );
+
+	let path = ltk::theme_branding_raster( "wallpaper", 0, 0 )
+		.expect( "(0, 0) returns the smallest raster" );
+	assert!
+	(
+		path.to_string_lossy().ends_with( "branding/light/wallpaper/1280x720.webp" ),
+		"unexpected raster for (0, 0): {}", path.display(),
+	);
+
+	let img = ltk::theme_branding_image( "wallpaper", 0, 0 )
+		.expect( "branding_image returns the same smallest raster" );
+	assert_eq!( img, path );
+}