From 854bc06897e010135c2c75aac42959dd30632d9f Mon Sep 17 00:00:00 2001 From: Zacharias Xenakis Date: Sun, 8 Nov 2026 17:14:15 +0200 Subject: [PATCH 1/3] refactor(scenes): start the scene and backup formats at version 1 --- src/backup.rs | 40 ++--------- src/scenes.rs | 183 +++++--------------------------------------------- 2 files changed, 19 insertions(+), 204 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index 0b8e7ea..f9c75cf 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -16,9 +16,8 @@ use std::{ }; const LIMIT: u64 = 8 * 1024 * 1024; -/// Version 2 drops audio presets: scenes hold their sound. Version 1 backups still restore; -/// their scenes' audio presets are migrated into the Sound step. -const VERSION: u8 = 2; +/// The backup file format. Other versions are refused. +const VERSION: u8 = 1; #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] @@ -26,9 +25,6 @@ struct Backup { version: u8, scenes: Vec, displays: Vec, - /// Version 1 audio presets, read only to migrate the scenes that used them. - #[serde(default, skip_serializing)] - audio: Option, tv_names: BTreeMap, } @@ -84,7 +80,6 @@ pub fn export(path: &Path) -> Result<(), String> { version: VERSION, scenes, displays, - audio: None, tv_names, }; let bytes = serde_json::to_vec_pretty(&backup).map_err(|e| e.to_string())?; @@ -114,16 +109,11 @@ fn read(path: &Path) -> Result { if bytes.len() as u64 > LIMIT { return Err("The backup is too large.".into()); } - let mut backup: Backup = + let backup: Backup = serde_json::from_slice(&bytes).map_err(|e| format!("Invalid Director backup: {e}"))?; - if !(1..=VERSION).contains(&backup.version) { + if backup.version != VERSION { return Err("This backup version is unsupported.".into()); } - let legacy = backup - .audio - .take() - .and_then(|v| v.get("presets").cloned().or(Some(v))); - scenes::migrate(&mut backup.scenes, legacy); scenes::validate_backup(&backup.scenes)?; displays::validate(&backup.displays)?; Ok(backup) @@ -279,7 +269,6 @@ mod tests { version: VERSION, scenes: vec![], displays: vec![], - audio: None, tv_names: BTreeMap::new(), }; let file = folder.join("Director.director-backup"); @@ -304,25 +293,4 @@ mod tests { restore_catalog(&import, &scene_path, &display_path).unwrap(); assert!(displays::load(&display_path).unwrap().is_empty()); } - - #[test] - fn version_one_backups_migrate_audio_presets_into_scene_sound() { - let folder = - std::env::temp_dir().join(format!("director-backup-v1-{}", std::process::id())); - fs::create_dir_all(&folder).unwrap(); - let file = folder.join("old.director-backup"); - let v1 = serde_json::json!({ - "version": 1, - "scenes": [{"id":"s","name":"Desk","display":null,"audio":"p","tv":null,"actions":[]}], - "displays": [], - "audio": [{"id":"p","name":"Desk sound","output_id":"soundbar","output_name":"SOUNDBAR","volume_percent":10,"keep_changes":false}], - "tv_names": {} - }); - fs::write(&file, serde_json::to_vec(&v1).unwrap()).unwrap(); - let backup = read(&file).unwrap(); - let sound = backup.scenes[0].sound.as_ref().unwrap(); - assert_eq!(sound.volume, Some(10)); - assert!(matches!(&sound.output, Some(SoundOutput::Device { id, .. }) if id == "soundbar")); - let _ = fs::remove_dir_all(folder); - } } diff --git a/src/scenes.rs b/src/scenes.rs index f7651ee..c8880ad 100644 --- a/src/scenes.rs +++ b/src/scenes.rs @@ -32,19 +32,6 @@ pub struct Scene { /// leave steps. #[serde(default, skip_serializing_if = "Option::is_none")] pub return_to: Option, - /// Version 1 per-scene policy. Read so old files load, never written; see `ScenePolicy`. - #[serde(default, rename = "keep_on_failure", skip_serializing)] - legacy_keep_on_failure: Option, - #[serde(default, rename = "wait_seconds", skip_serializing)] - legacy_wait_seconds: Option, - /// Version 1–2 audio preset reference and linked TV audio. Read so old files load and - /// migrate into sound, never written. - #[serde(default, rename = "audio", skip_serializing)] - legacy_audio: Option, - #[serde(default, rename = "tv_audio", skip_serializing)] - legacy_tv_audio: Option, - #[serde(default, rename = "tv_audio_volume", skip_serializing)] - legacy_tv_audio_volume: Option, } /// Resolve before any leave actions. A missing destination must keep the scene active. pub fn return_destination<'a>( @@ -363,37 +350,6 @@ impl Scene { } Ok(()) } - /// Drop version 1 per-scene policy fields once they have been read, and move version 1–2 - /// audio into the Sound step. A preset that can't be found leaves an empty Sound step, so - /// the scene asks to be edited instead of silently losing its sound. - fn normalize(&mut self, presets: &[LegacyPreset]) { - self.legacy_keep_on_failure = None; - self.legacy_wait_seconds = None; - let tv = self.legacy_tv_audio.take(); - let volume = self.legacy_tv_audio_volume.take(); - let preset = self.legacy_audio.take(); - if self.sound.is_some() { - return; - } - if let Some(id) = tv { - self.sound = Some(Sound { - output: Some(SoundOutput::Tv { id }), - volume, - ..Default::default() - }); - } else if let Some(id) = preset { - self.sound = Some( - presets - .iter() - .find(|p| p.id == id) - .map(LegacyPreset::sound) - .unwrap_or_default(), - ); - } - } - fn has_legacy_audio(&self) -> bool { - self.legacy_audio.is_some() - } } #[derive(Clone)] pub struct Plan { @@ -491,66 +447,6 @@ pub fn sound_request( }), }) } -/// An audio preset from `audio-presets.json`, which version 1–2 scenes referred to. Read -/// only to migrate those scenes; Director no longer writes this file. -#[derive(Deserialize)] -struct LegacyPreset { - id: String, - output_id: String, - output_name: String, - volume_percent: Option, - #[serde(default)] - communications_output: Option, - #[serde(default)] - input: Option, -} -#[derive(Deserialize)] -struct LegacyInput { - id: String, - name: String, - volume_percent: Option, -} -impl LegacyPreset { - fn sound(&self) -> Sound { - Sound { - output: Some(SoundOutput::Device { - id: self.output_id.clone(), - name: self.output_name.clone(), - }), - volume: self.volume_percent, - mute: None, - calls: self.communications_output.clone(), - mic: self.input.as_ref().map(|i| Mic { - device: DeviceSelection { - id: i.id.clone(), - name: i.name.clone(), - }, - volume: i.volume_percent, - mute: None, - }), - } - } -} -/// Migrate version 1–2 scenes read from somewhere other than the scene file (a backup), -/// using the audio presets stored alongside them. -pub(crate) fn migrate(scenes: &mut [Scene], legacy_presets: Option) { - let presets: Vec = legacy_presets - .and_then(|v| serde_json::from_value(v).ok()) - .unwrap_or_default(); - scenes.iter_mut().for_each(|s| s.normalize(&presets)); -} -/// Saved audio presets next to `scenes`, for migration. Missing or unreadable means none. -fn legacy_presets(scenes: &Path) -> Vec { - #[derive(Deserialize)] - struct Document { - presets: Vec, - } - fs::read(scenes.with_file_name("audio-presets.json")) - .ok() - .and_then(|bytes| serde_json::from_slice::(&bytes).ok()) - .map(|d| d.presets) - .unwrap_or_default() -} #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] struct Document { @@ -599,19 +495,13 @@ pub fn load(path: &Path) -> Result, String> { if data.len() > STORAGE_LIMIT { return Err("Scene file is too large. It was left unchanged.".into()); } - let mut doc: Document = serde_json::from_slice(&data) + let doc: Document = serde_json::from_slice(&data) .map_err(|_| "Could not read scenes. The file was left unchanged.")?; - if !(1..=VERSION).contains(&doc.version) { + if doc.version != VERSION { return Err( "These scenes require a newer Director version. The file was left unchanged.".into(), ); } - let presets = if doc.scenes.iter().any(Scene::has_legacy_audio) { - legacy_presets(path) - } else { - Vec::new() - }; - doc.scenes.iter_mut().for_each(|s| s.normalize(&presets)); validate(&doc.scenes)?; Ok(doc.scenes) } @@ -629,10 +519,8 @@ pub fn save(path: &Path, expected: &[Scene], next: &[Scene]) -> Result<(), Strin }, ) } -/// Version 2 adds Before/Leave actions, waited apps and Close actions, and drops the -/// per-scene failure policy. Version 3 replaces the audio preset reference and linked TV -/// audio with the inline Sound step. Version 1 and 2 files still load and migrate. -const VERSION: u32 = 4; +/// The scenes file format. Other versions are refused and left unchanged. +const VERSION: u32 = 1; pub fn references(kind: &str, id: &str) -> Result, String> { Ok(load(&path()?)? .into_iter() @@ -966,10 +854,6 @@ mod tests { b.calls.clear(); assert!(!apply(&mut b, &p, &AtomicBool::new(false), |_| {}).success); assert_eq!(b.calls, ["snapshot", "fps"]); - let mut legacy = serde_json::to_value(scene()).unwrap(); - legacy.as_object_mut().unwrap().remove("fps"); - let legacy: Scene = serde_json::from_value(legacy).unwrap(); - assert!(legacy.fps.is_none()); let mut only = s; only.actions.clear(); assert!(only.validate().is_ok()); @@ -1220,19 +1104,19 @@ mod tests { assert_eq!(warnings.len(), 1); } #[test] - fn version_one_files_load_and_save_as_the_current_version_without_policy_fields() { + fn files_save_as_version_one_and_other_versions_are_refused() { let path = - std::env::temp_dir().join(format!("director-scenes-v1-{}.json", std::process::id())); - let v1 = serde_json::json!({"version":1,"scenes":[{"id":"s","name":"Desk","display":null,"audio":null,"tv":null,"actions":[{"kind":"uri","target":"steam://close/bigpicture"}],"keep_on_failure":true,"wait_seconds":45}]}); - fs::write(&path, serde_json::to_vec(&v1).unwrap()).unwrap(); - let loaded = load(&path).unwrap(); - assert_eq!(loaded[0].legacy_keep_on_failure, None); - save(&path, &loaded, &loaded).unwrap(); + std::env::temp_dir().join(format!("director-scenes-version-{}.json", std::process::id())); + let scenes = vec![scene()]; + save(&path, &[], &scenes).unwrap(); let written: serde_json::Value = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap(); - assert_eq!(written["version"], 4); - let scene = &written["scenes"][0]; - assert!(scene.get("keep_on_failure").is_none() && scene.get("wait_seconds").is_none()); - assert_eq!(load(&path).unwrap(), loaded); + assert_eq!(written["version"], 1); + assert_eq!(load(&path).unwrap(), scenes); + let mut other = written.clone(); + other["version"] = 2.into(); + fs::write(&path, serde_json::to_vec(&other).unwrap()).unwrap(); + assert!(load(&path).is_err()); + assert_eq!(fs::read(&path).unwrap(), serde_json::to_vec(&other).unwrap()); let _ = fs::remove_file(path); } #[test] @@ -1256,43 +1140,6 @@ mod tests { assert_eq!(request.mute, Some(false)); } #[test] - fn version_two_audio_presets_and_tv_audio_migrate_into_sound() { - let dir = - std::env::temp_dir().join(format!("director-scene-migrate-{}", std::process::id())); - fs::create_dir_all(&dir).unwrap(); - let path = dir.join("scenes.json"); - fs::write( - dir.join("audio-presets.json"), - serde_json::to_vec(&serde_json::json!({"version":1,"presets":[{"id":"p","name":"Desk sound","output_id":"soundbar","output_name":"SOUNDBAR","volume_percent":10,"keep_changes":false,"input":{"id":"mic","name":"Mic","volume_percent":80}}]})).unwrap(), - ) - .unwrap(); - let v2 = serde_json::json!({"version":2,"scenes":[ - {"id":"a","name":"Desk","display":null,"audio":"p","tv":null,"actions":[]}, - {"id":"b","name":"Couch","display":null,"audio":null,"tv_audio":"tv","tv_audio_volume":30,"tv":null,"actions":[]}, - {"id":"c","name":"Lost","display":null,"audio":"gone","tv":null,"actions":[]} - ]}); - fs::write(&path, serde_json::to_vec(&v2).unwrap()).unwrap(); - let loaded = load(&path).unwrap(); - let desk = loaded[0].sound.as_ref().unwrap(); - assert_eq!( - desk.output, - Some(SoundOutput::Device { - id: "soundbar".into(), - name: "SOUNDBAR".into() - }) - ); - assert_eq!(desk.volume, Some(10)); - assert_eq!(desk.mic.as_ref().unwrap().volume, Some(80)); - assert_eq!(loaded[1].sound, Some(tv_sound(Some(30)))); - assert_eq!(loaded[2].sound, Some(Sound::default())); - save(&path, &loaded, &loaded).unwrap(); - let written: serde_json::Value = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap(); - assert_eq!(written["version"], 4); - assert!(written["scenes"][0].get("audio").is_none()); - assert_eq!(load(&path).unwrap(), loaded); - let _ = fs::remove_dir_all(dir); - } - #[test] fn leaving_turns_the_tv_off_after_the_leave_actions() { let tv = serde_json::from_value::(serde_json::json!({"id":"tv","name":"C1","address":"192.0.2.50","display":null,"credential":[1]})).unwrap(); let mut s = scene(); From b5b95e65c5fa55fb2e2086cc5b00c7d65f563179 Mon Sep 17 00:00:00 2001 From: Zacharias Xenakis Date: Sun, 8 Nov 2026 17:16:34 +0200 Subject: [PATCH 2/3] refactor: drop compatibility defaults for display, TV and preference files --- src/displays.rs | 14 +++----------- src/preferences.rs | 33 ++++++--------------------------- src/samsung.rs | 4 ++-- src/scenes.rs | 4 ++-- src/tvs.rs | 34 ++++++++-------------------------- 5 files changed, 21 insertions(+), 68 deletions(-) diff --git a/src/displays.rs b/src/displays.rs index 2dbecaa..40446dd 100644 --- a/src/displays.rs +++ b/src/displays.rs @@ -64,7 +64,7 @@ pub struct Monitor { pub device_path: Option, pub name: String, pub connected: bool, - /// None preserves legacy behavior: leave HDR unchanged. + /// None leaves the screen's HDR state as it is when the preset is applied. #[serde(default, skip_serializing_if = "Option::is_none")] pub hdr: Option, pub enabled: bool, @@ -152,13 +152,9 @@ pub struct Preset { pub id: String, pub name: String, pub captured_at_unix_seconds: u64, - #[serde(default = "confirmation_default")] pub confirm_changes: bool, pub layout: Layout, } -fn confirmation_default() -> bool { - true -} #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] struct Document { @@ -287,13 +283,9 @@ pub(crate) mod tests { ); } #[test] - fn legacy_presets_require_confirmation_and_opt_out_round_trips() { + fn confirmation_opt_out_round_trips() { let original = sample(); - let mut json = serde_json::to_value(&original).unwrap(); - json.as_object_mut().unwrap().remove("confirm_changes"); - let legacy: Preset = serde_json::from_value(json).unwrap(); - assert!(legacy.confirm_changes); - let mut automatic = legacy.clone(); + let mut automatic = original.clone(); automatic.confirm_changes = false; let restored: Preset = serde_json::from_slice(&serde_json::to_vec(&automatic).unwrap()).unwrap(); diff --git a/src/preferences.rs b/src/preferences.rs index 9af8bdf..e1e9bec 100644 --- a/src/preferences.rs +++ b/src/preferences.rs @@ -8,23 +8,19 @@ pub struct Preferences { pub hide_tv_setup_tip: bool, #[serde(default)] pub notify_scene_failures: bool, - /// Keep steps that finished when a later scene or audio preset step fails. + /// Keep steps that finished when a later scene step fails. #[serde(default)] pub keep_completed_changes: bool, /// How long scenes wait for a TV or audio device, and for waited apps (1–120 s). #[serde(default = "default_wait")] pub device_wait_seconds: u16, - /// The Scenes page's "make your next scene" tip was dismissed. Written only when set, so - /// older builds keep reading the file until the tip is dismissed. - #[serde(default, skip_serializing_if = "std::ops::Not::not")] + /// The Scenes page's "make your next scene" tip was dismissed. + #[serde(default)] pub hide_next_scene_tip: bool, /// After a scene selects a TV input, keep switching back to it for this long when a TV /// box or console takes the input over (0–60 s, 0 = off). Only for TVs that report - /// their input. Written only when changed, so older builds keep reading the file. - #[serde( - default = "default_input_guard", - skip_serializing_if = "is_default_input_guard" - )] + /// their input. + #[serde(default = "default_input_guard")] pub tv_input_guard_seconds: u16, } fn default_wait() -> u16 { @@ -33,9 +29,6 @@ fn default_wait() -> u16 { fn default_input_guard() -> u16 { crate::tv_input_guard::DEFAULT_SECONDS } -fn is_default_input_guard(seconds: &u16) -> bool { - *seconds == default_input_guard() -} impl Default for Preferences { fn default() -> Self { Self { @@ -127,13 +120,6 @@ mod tests { assert_eq!(initial.device_wait_seconds, 30); assert!(!initial.hide_next_scene_tip); assert_eq!(initial.tv_input_guard_seconds, 10); - std::fs::write( - &path, - br#"{"version":1,"preferences":{"hide_tv_setup_tip":false,"notify_scene_failures":false,"keep_completed_changes":false,"device_wait_seconds":30}}"#, - ) - .unwrap(); - assert_eq!(load(&path).unwrap(), initial, "older files still load"); - std::fs::remove_file(&path).unwrap(); assert_eq!(initial.audio_policy(), crate::audio::FailurePolicy::Revert); let hidden = Preferences { hide_tv_setup_tip: true, @@ -146,15 +132,8 @@ mod tests { save(&path, &initial, &hidden).unwrap(); assert_eq!(load(&path).unwrap(), hidden); assert_eq!(hidden.scene_policy().input_guard_seconds, 0); - let written = std::fs::read_to_string(&path).unwrap(); - assert!(written.contains("tv_input_guard_seconds")); save(&path, &hidden, &initial).unwrap(); - assert!( - !std::fs::read_to_string(&path) - .unwrap() - .contains("tv_input_guard_seconds"), - "the default stays out of the file for older builds" - ); + assert_eq!(load(&path).unwrap(), initial); save(&path, &initial, &hidden).unwrap(); assert!(save(&path, &initial, &initial).is_err()); let future = br#"{"version":99,"preferences":{"hide_tv_setup_tip":false}}"#; diff --git a/src/samsung.rs b/src/samsung.rs index 85e6b9d..89675fb 100644 --- a/src/samsung.rs +++ b/src/samsung.rs @@ -221,7 +221,7 @@ pub fn report(tv: &crate::tvs::Tv) -> Result { test.firmware = clean(&test.firmware); } Ok(CompatibilityReport { - format_version: 2, + format_version: 1, director_version: env!("CARGO_PKG_VERSION"), brand: tv.brand.label(), model: clean(&tv.compatibility().model), @@ -320,7 +320,7 @@ mod tests { } #[test] fn report_is_an_allowlist_and_never_serializes_secrets_or_addresses() { - let tv:crate::tvs::Tv=serde_json::from_value(serde_json::json!({"id":"private-id","name":"private-alias","brand":"samsung","address":"192.0.2.50","display":null,"credential":[1,2,3],"samsung":{"model":"S90C","firmware":"1234","tests":[]}})).unwrap(); + let tv:crate::tvs::Tv=serde_json::from_value(serde_json::json!({"id":"private-id","name":"private-alias","brand":"samsung","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[1,2,3],"samsung":{"model":"S90C","firmware":"1234","tests":[]}})).unwrap(); let data = serde_json::to_string(&report(&tv).unwrap()).unwrap(); assert!(data.contains("S90C")); for value in [ diff --git a/src/scenes.rs b/src/scenes.rs index c8880ad..8e405eb 100644 --- a/src/scenes.rs +++ b/src/scenes.rs @@ -971,7 +971,7 @@ mod tests { assert_eq!(b.calls, ["snapshot", "display", "audio"]); } fn linked_tv() -> crate::tvs::Tv { - serde_json::from_value(serde_json::json!({"id":"tv","name":"C1","address":"192.0.2.50","display":null,"credential":[1],"audio":{"id":"hdmi","name":"LG HDMI"}})).unwrap() + serde_json::from_value(serde_json::json!({"id":"tv","name":"C1","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[1],"audio":{"id":"hdmi","name":"LG HDMI"}})).unwrap() } fn tv_sound(volume: Option) -> Sound { Sound { @@ -1141,7 +1141,7 @@ mod tests { } #[test] fn leaving_turns_the_tv_off_after_the_leave_actions() { - let tv = serde_json::from_value::(serde_json::json!({"id":"tv","name":"C1","address":"192.0.2.50","display":null,"credential":[1]})).unwrap(); + let tv = serde_json::from_value::(serde_json::json!({"id":"tv","name":"C1","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[1]})).unwrap(); let mut s = scene(); s.tv = Some(TvPreparation { id: "tv".into(), diff --git a/src/tvs.rs b/src/tvs.rs index eb31227..2691803 100644 --- a/src/tvs.rs +++ b/src/tvs.rs @@ -42,13 +42,11 @@ pub struct Tv { pub id: String, pub name: String, pub address: String, - #[serde(default)] pub brand: Brand, #[serde(default)] pub samsung: crate::samsung::Metadata, #[serde(default)] pub android: crate::samsung::Metadata, - #[serde(default)] pub connection: Connection, pub display: Option, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -321,21 +319,11 @@ mod tests { } #[cfg(test)] -mod compatibility_tests { +mod tv_file_tests { use super::*; #[test] - fn legacy_paired_tv_keeps_credential_with_new_optional_metadata() { - let old = serde_json::json!({"id":"legacy","name":"TV","address":"192.0.2.50","connection":"encrypted","display":null,"credential":[1,2,3]}); - let tv: Tv = serde_json::from_value(old).unwrap(); - assert!(tv.credential == Some(vec![1, 2, 3])); - assert!(tv.inputs.is_empty()); - assert!(tv.pc_input.is_none()); - assert!(tv.network.targets().is_empty()); - tv.validate().unwrap(); - } - #[test] fn audio_link_roundtrips_without_repairing_or_changing_display() { - let mut t:Tv=serde_json::from_value(serde_json::json!({"id":"link","name":"TV","address":"192.0.2.50","display":null,"credential":[4,8]})).unwrap(); + let mut t:Tv=serde_json::from_value(serde_json::json!({"id":"link","name":"TV","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[4,8]})).unwrap(); let old = t.clone(); t.audio = Some(crate::audio::DeviceSelection { id: "remembered-hdmi".into(), @@ -347,17 +335,16 @@ mod compatibility_tests { let data = serde_json::to_vec(&t).unwrap(); let back: Tv = serde_json::from_slice(&data).unwrap(); assert!(back == t); - let mut legacy = serde_json::to_value(&t).unwrap(); - legacy.as_object_mut().unwrap().remove("audio"); - let back: Tv = serde_json::from_value(legacy).unwrap(); + let mut unlinked = serde_json::to_value(&t).unwrap(); + unlinked.as_object_mut().unwrap().remove("audio"); + let back: Tv = serde_json::from_value(unlinked).unwrap(); assert!(back.audio.is_none()); t.audio.as_mut().unwrap().id.clear(); assert!(t.validate().is_err()); } #[test] - fn legacy_tv_defaults_to_lg_and_brand_change_invalidates_auth_and_tests() { - let mut tv:Tv=serde_json::from_value(serde_json::json!({"id":"legacy","name":"LG","address":"192.0.2.50","display":null,"credential":[1,2]})).unwrap(); - assert_eq!(tv.brand, Brand::Lg); + fn brand_change_invalidates_auth_and_tests() { + let mut tv:Tv=serde_json::from_value(serde_json::json!({"id":"legacy","name":"LG","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[1,2]})).unwrap(); let old = tv.clone(); tv.brand = Brand::Samsung; tv.samsung.record(2, true); @@ -366,12 +353,7 @@ mod compatibility_tests { } #[test] fn android_metadata_is_independent_and_reports_omit_private_identity() { - let mut tv:Tv=serde_json::from_value(serde_json::json!({"id":"private-tv-id-123","name":"Private living room alias","address":"192.0.2.50","display":null,"credential":null})).unwrap(); - let legacy = serde_json::to_value(&tv).unwrap(); - let mut old = legacy.as_object().unwrap().clone(); - old.remove("android"); - let loaded: Tv = serde_json::from_value(old.into()).unwrap(); - assert!(loaded.android.tests.is_empty()); + let mut tv:Tv=serde_json::from_value(serde_json::json!({"id":"private-tv-id-123","name":"Private living room alias","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":null})).unwrap(); tv.brand = Brand::TclAndroid; tv.credential = Some(vec![21, 42]); tv.android.model = Some("TCL fixture".into()); From 14c97b2165f0ea6388bc9f8d2414a28282b186ba Mon Sep 17 00:00:00 2001 From: Zacharias Xenakis Date: Sun, 8 Nov 2026 17:18:52 +0200 Subject: [PATCH 3/3] refactor: remove old CLI spellings, the per-user setup check and stale comments --- installer/DirectorSetup.wxs | 6 ------ src/audio_devices.rs | 4 ++-- src/cli.rs | 10 ++++------ src/cli_name.rs | 4 ++-- src/current_ui.rs | 4 ++-- src/display_apply.rs | 6 +++--- src/scenes.rs | 11 ++++++++--- src/tvs.rs | 2 +- 8 files changed, 22 insertions(+), 25 deletions(-) diff --git a/installer/DirectorSetup.wxs b/installer/DirectorSetup.wxs index 0cf7caf..a14bd57 100644 --- a/installer/DirectorSetup.wxs +++ b/installer/DirectorSetup.wxs @@ -28,12 +28,6 @@ - - - list` and the other read-only lists, with an optional -/// `--json`. Older spellings (`display presets`, `display current`) still work. +/// `--json`. fn list_command(args: &[String]) -> Option<(&'static [crate::cli_list::Category], bool, bool)> { use crate::cli_list::Category; let mut words: Vec<&str> = args.iter().map(String::as_str).collect(); @@ -67,8 +67,8 @@ fn list_command(args: &[String]) -> Option<(&'static [crate::cli_list::Category] let categories: &'static [Category] = match words.as_slice() { ["list"] => &Category::ALL, ["scene", "list"] => &[Category::Scenes], - ["display", "list" | "presets"] => &[Category::DisplayPresets], - ["display", "screens" | "current"] => &[Category::Screens], + ["display", "list"] => &[Category::DisplayPresets], + ["display", "screens"] => &[Category::Screens], ["audio", "list"] => &[Category::AudioOutputs, Category::AudioInputs], ["audio", "outputs"] => &[Category::AudioOutputs], ["audio", "inputs"] => &[Category::AudioInputs], @@ -146,9 +146,7 @@ mod tests { for (command, wanted) in [ ("scene list", Category::Scenes), ("display list", Category::DisplayPresets), - ("display presets", Category::DisplayPresets), ("display screens", Category::Screens), - ("display current", Category::Screens), ("audio outputs", Category::AudioOutputs), ("audio inputs --json", Category::AudioInputs), ("tv list", Category::Tvs), @@ -158,7 +156,7 @@ mod tests { "{command}" ); } - assert!(list("audio presets").is_none()); + assert!(list("display presets").is_none()); assert!(list("list scenes").is_none()); assert!(list("audio list extra").is_none()); assert!(list("scene apply desk").is_none()); diff --git a/src/cli_name.rs b/src/cli_name.rs index 1073101..c22d9ed 100644 --- a/src/cli_name.rs +++ b/src/cli_name.rs @@ -1,8 +1,8 @@ //! Command-line names: "Desk View" is `desk-view`, so names never need quotes. //! //! CLI names are derived from the saved name every time and never stored. Lookups accept an -//! exact ID or anything that normalizes to the same CLI name, so older quoted commands such -//! as `"Desk View"` keep working. +//! exact ID or anything that normalizes to the same CLI name, so a quoted name such as +//! `"Desk View"` works too. /// Lowercase letters and digits, with every run of other characters turned into one `-`. /// Empty only for a name made entirely of symbols. diff --git a/src/current_ui.rs b/src/current_ui.rs index 223c67d..dae8b20 100644 --- a/src/current_ui.rs +++ b/src/current_ui.rs @@ -117,8 +117,8 @@ impl CurrentState { self.display.editor = Some(Editor::new(&layout, options)); self.display.drag = None; self.display.draft = Some(Preset { - id: "current-setup-session".into(), - name: "Current setup".into(), + id: "now-session".into(), + name: "Now".into(), captured_at_unix_seconds: 0, confirm_changes: false, layout, diff --git a/src/display_apply.rs b/src/display_apply.rs index 114dda0..0a2c6d2 100644 --- a/src/display_apply.rs +++ b/src/display_apply.rs @@ -432,9 +432,9 @@ pub(crate) mod tests { let result = apply(&mut backend, &wanted, || true); assert_eq!(result.outcome, Outcome::Failed); assert_eq!(backend.current.monitors[0].hdr, Some(false)); - let mut legacy = wanted.clone(); - legacy.monitors[0].hdr = None; - assert!(verify(&legacy, &before).is_ok()); + let mut unset = wanted.clone(); + unset.monitors[0].hdr = None; + assert!(verify(&unset, &before).is_ok()); } #[test] fn no_op_and_preflight_failures_never_write() { diff --git a/src/scenes.rs b/src/scenes.rs index 8e405eb..e637fa3 100644 --- a/src/scenes.rs +++ b/src/scenes.rs @@ -1105,8 +1105,10 @@ mod tests { } #[test] fn files_save_as_version_one_and_other_versions_are_refused() { - let path = - std::env::temp_dir().join(format!("director-scenes-version-{}.json", std::process::id())); + let path = std::env::temp_dir().join(format!( + "director-scenes-version-{}.json", + std::process::id() + )); let scenes = vec![scene()]; save(&path, &[], &scenes).unwrap(); let written: serde_json::Value = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap(); @@ -1116,7 +1118,10 @@ mod tests { other["version"] = 2.into(); fs::write(&path, serde_json::to_vec(&other).unwrap()).unwrap(); assert!(load(&path).is_err()); - assert_eq!(fs::read(&path).unwrap(), serde_json::to_vec(&other).unwrap()); + assert_eq!( + fs::read(&path).unwrap(), + serde_json::to_vec(&other).unwrap() + ); let _ = fs::remove_file(path); } #[test] diff --git a/src/tvs.rs b/src/tvs.rs index 2691803..bdae077 100644 --- a/src/tvs.rs +++ b/src/tvs.rs @@ -344,7 +344,7 @@ mod tv_file_tests { } #[test] fn brand_change_invalidates_auth_and_tests() { - let mut tv:Tv=serde_json::from_value(serde_json::json!({"id":"legacy","name":"LG","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[1,2]})).unwrap(); + let mut tv:Tv=serde_json::from_value(serde_json::json!({"id":"lg","name":"LG","brand":"lg","connection":"encrypted","address":"192.0.2.50","display":null,"credential":[1,2]})).unwrap(); let old = tv.clone(); tv.brand = Brand::Samsung; tv.samsung.record(2, true);