From 5a14eef258aa0da11ece0fce9c681d067b632cfb Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Mon, 24 Aug 2026 17:28:54 -0600 Subject: [PATCH] fix(metadata): complete local editor sessions Consume preflight data when loading clears so the modal cannot spin indefinitely. Reuse the editor for ephemeral folders and bind sidecar or direct writes to the exact active session. cx --- .../translations/de/LC_MESSAGES/qbz-ui.po | 3 + .../translations/en/LC_MESSAGES/qbz-ui.po | 3 + .../translations/es/LC_MESSAGES/qbz-ui.po | 3 + .../translations/fr/LC_MESSAGES/qbz-ui.po | 3 + .../translations/ja/LC_MESSAGES/qbz-ui.po | 3 + .../translations/nl/LC_MESSAGES/qbz-ui.po | 3 + .../translations/pt/LC_MESSAGES/qbz-ui.po | 3 + .../translations/ru/LC_MESSAGES/qbz-ui.po | 3 + crates/qbz-library/src/ephemeral.rs | 125 +++++++++++++- crates/qbz-qt/qml/controls/TagEditorModal.qml | 8 + .../qml/views/local/LocalEphemeralPane.qml | 42 ++++- crates/qbz-qt/src/local_bridge.rs | 8 + crates/qbz-qt/src/local_ephemeral.rs | 52 ++++++ crates/qbz-qt/src/tag_editor_qt.rs | 163 ++++++++++++++++-- 14 files changed, 404 insertions(+), 18 deletions(-) diff --git a/crates/qbz-i18n/translations/de/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/de/LC_MESSAGES/qbz-ui.po index d25826123..5b5955f36 100644 --- a/crates/qbz-i18n/translations/de/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/de/LC_MESSAGES/qbz-ui.po @@ -5815,3 +5815,6 @@ msgstr "Medium öffnen" msgid "Open folder…" msgstr "Ordner öffnen…" + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "Die temporäre Sitzung wurde geändert; öffne den Metadaten-Editor erneut." diff --git a/crates/qbz-i18n/translations/en/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/en/LC_MESSAGES/qbz-ui.po index 762aecb43..0efd95baf 100644 --- a/crates/qbz-i18n/translations/en/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/en/LC_MESSAGES/qbz-ui.po @@ -1390,3 +1390,6 @@ msgstr "tracks" msgid "{} must be a positive number." msgstr "{} must be a positive number." + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "The ephemeral session changed; reopen the metadata editor." diff --git a/crates/qbz-i18n/translations/es/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/es/LC_MESSAGES/qbz-ui.po index 7bfcaa50b..5ff873954 100644 --- a/crates/qbz-i18n/translations/es/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/es/LC_MESSAGES/qbz-ui.po @@ -5821,3 +5821,6 @@ msgstr "Abrir medios" msgid "Open folder…" msgstr "Abrir carpeta…" + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "La sesión efímera cambió; vuelve a abrir el editor de metadatos." diff --git a/crates/qbz-i18n/translations/fr/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/fr/LC_MESSAGES/qbz-ui.po index bb4fa4806..b5bde7f32 100644 --- a/crates/qbz-i18n/translations/fr/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/fr/LC_MESSAGES/qbz-ui.po @@ -5813,3 +5813,6 @@ msgstr "Ouvrir un média" msgid "Open folder…" msgstr "Ouvrir un dossier…" + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "La session éphémère a changé ; rouvrez l’éditeur de métadonnées." diff --git a/crates/qbz-i18n/translations/ja/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/ja/LC_MESSAGES/qbz-ui.po index 9d9a0c41d..930bba51b 100644 --- a/crates/qbz-i18n/translations/ja/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/ja/LC_MESSAGES/qbz-ui.po @@ -5798,3 +5798,6 @@ msgstr "メディアを開く" msgid "Open folder…" msgstr "フォルダーを開く…" + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "一時セッションが変更されました。メタデータエディターを開き直してください。" diff --git a/crates/qbz-i18n/translations/nl/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/nl/LC_MESSAGES/qbz-ui.po index 2686e7b60..8c2cdd480 100644 --- a/crates/qbz-i18n/translations/nl/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/nl/LC_MESSAGES/qbz-ui.po @@ -5802,3 +5802,6 @@ msgstr "Het jaar moet een geldig getal zijn." msgid "{} must be a positive number." msgstr "{} moet een positief getal zijn." + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "De tijdelijke sessie is gewijzigd; open de metadata-editor opnieuw." diff --git a/crates/qbz-i18n/translations/pt/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/pt/LC_MESSAGES/qbz-ui.po index 421670d31..feedf1242 100644 --- a/crates/qbz-i18n/translations/pt/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/pt/LC_MESSAGES/qbz-ui.po @@ -5813,3 +5813,6 @@ msgstr "Abrir mídia" msgid "Open folder…" msgstr "Abrir pasta…" + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "A sessão efêmera mudou; reabra o editor de metadados." diff --git a/crates/qbz-i18n/translations/ru/LC_MESSAGES/qbz-ui.po b/crates/qbz-i18n/translations/ru/LC_MESSAGES/qbz-ui.po index 7b32e0c4c..39a3bc8df 100644 --- a/crates/qbz-i18n/translations/ru/LC_MESSAGES/qbz-ui.po +++ b/crates/qbz-i18n/translations/ru/LC_MESSAGES/qbz-ui.po @@ -5832,3 +5832,6 @@ msgstr "Открыть медиафайл" msgid "Open folder…" msgstr "Открыть папку…" + +msgid "The ephemeral session changed; reopen the metadata editor." +msgstr "Эфемерный сеанс изменился; снова откройте редактор метаданных." diff --git a/crates/qbz-library/src/ephemeral.rs b/crates/qbz-library/src/ephemeral.rs index e6accb332..b4f0cff4f 100644 --- a/crates/qbz-library/src/ephemeral.rs +++ b/crates/qbz-library/src/ephemeral.rs @@ -32,9 +32,31 @@ use std::collections::{HashMap, HashSet}; use std::path::{Path, PathBuf}; use std::sync::Mutex; -use crate::{cue_to_tracks, CueParser, LibraryError, LibraryScanner, LocalTrack, MetadataExtractor}; +use crate::{ + cue_to_tracks, AlbumTagSidecar, CueParser, LibraryError, LibraryScanner, LocalTrack, + MetadataExtractor, +}; use serde::Serialize; +fn apply_sidecar_override( + track: &mut LocalTrack, + cache: &mut HashMap>, +) { + let own_directory = Path::new(&track.file_path).parent().map(Path::to_path_buf); + let grouped_directory = (!track.album_group_key.trim().is_empty()) + .then(|| PathBuf::from(&track.album_group_key)) + .filter(|path| path.is_dir()); + for directory in grouped_directory.into_iter().chain(own_directory) { + let sidecar = cache + .entry(directory.clone()) + .or_insert_with(|| crate::read_album_sidecar(&directory).unwrap_or(None)); + if let Some(sidecar) = sidecar.as_ref() { + crate::apply_sidecar_to_track(track, sidecar); + return; + } + } +} + /// Floor for synthetic ephemeral track ids. Any id at or above this /// value is an ephemeral track; below it is a DB row id. Set high /// enough to be impossible to collide with autoincrement DB ids in any @@ -145,6 +167,7 @@ impl EphemeralLibraryState { // share the same parent directory. let mut album_artwork_cache: HashMap> = HashMap::new(); let mut folder_artwork_cache: HashMap> = HashMap::new(); + let mut sidecar_cache: HashMap> = HashMap::new(); // Audio files referenced by CUE sheets. We index those audio files // through the CUE path (one logical "album" file gets exploded @@ -249,6 +272,7 @@ impl EphemeralLibraryState { }; for mut track in cue_tracks.drain(..) { + apply_sidecar_override(&mut track, &mut sidecar_cache); track.id = inner.next_id; inner.next_id += 1; track.source = Some("ephemeral".to_string()); @@ -353,6 +377,7 @@ impl EphemeralLibraryState { } match extracted { Ok(mut track) => { + apply_sidecar_override(&mut track, &mut sidecar_cache); track.id = inner.next_id; inner.next_id += 1; track.source = Some("ephemeral".to_string()); @@ -519,6 +544,36 @@ impl EphemeralLibraryState { Ok(()) } + /// Replace a bounded subset only while the same folder/disc session is + /// still open. The exact id/path check prevents a draft from a dismissed + /// editor from mutating a later session that reused the synthetic ids. + pub fn replace_tracks_for_session( + &self, + expected_folder_path: &str, + tracks: &[LocalTrack], + ) -> Result>, EphemeralError> { + let mut inner = self.inner.lock().map_err(|_| EphemeralError::Lock)?; + if inner.current_folder_path.as_deref() != Some(expected_folder_path) { + return Ok(None); + } + for track in tracks { + let Some(current) = inner.tracks.get(&track.id) else { + return Ok(None); + }; + if current.file_path != track.file_path + || current.cue_start_secs != track.cue_start_secs + { + return Ok(None); + } + } + for track in tracks { + inner.tracks.insert(track.id, track.clone()); + } + let mut snapshot = inner.tracks.values().cloned().collect::>(); + snapshot.sort_by_key(|track| track.id); + Ok(Some(snapshot)) + } + pub fn clear(&self) { if let Ok(mut inner) = self.inner.lock() { inner.reset(); @@ -556,3 +611,71 @@ impl Default for EphemeralLibraryState { Self::new() } } + +#[cfg(test)] +mod editor_tests { + use super::*; + + fn track_at(path: &Path) -> LocalTrack { + LocalTrack { + file_path: path.to_string_lossy().into_owned(), + title: "Before".to_string(), + album: "Before album".to_string(), + album_group_title: "Before album".to_string(), + artist: "Artist".to_string(), + ..LocalTrack::default() + } + } + + #[test] + fn sidecar_overrides_are_visible_to_ephemeral_scans() { + let temp = tempfile::tempdir().unwrap(); + let file = temp.path().join("01.flac"); + let sidecar = crate::AlbumTagSidecar::new( + crate::AlbumMetadataOverride { + album_title: Some("After album".to_string()), + album_artist: Some("After artist".to_string()), + ..crate::AlbumMetadataOverride::default() + }, + vec![crate::TrackMetadataOverride { + file_path: file.to_string_lossy().into_owned(), + cue_start_secs: None, + title: Some("After".to_string()), + disc_number: Some(1), + track_number: Some(1), + }], + ); + crate::write_album_sidecar(temp.path(), &sidecar).unwrap(); + + let mut track = track_at(&file); + let mut cache = HashMap::new(); + apply_sidecar_override(&mut track, &mut cache); + + assert_eq!(track.album, "After album"); + assert_eq!(track.album_artist.as_deref(), Some("After artist")); + assert_eq!(track.title, "After"); + } + + #[test] + fn stale_editor_snapshot_cannot_retarget_a_new_ephemeral_session() { + let state = EphemeralLibraryState::new(); + let first = state + .open_tracks("first", vec![track_at(Path::new("/music/first.flac"))]) + .unwrap(); + let mut edited = first.tracks; + edited[0].title = "Edited".to_string(); + assert!(state + .replace_tracks_for_session("first", &edited) + .unwrap() + .is_some()); + + state + .open_tracks("second", vec![track_at(Path::new("/music/second.flac"))]) + .unwrap(); + assert!(state + .replace_tracks_for_session("first", &edited) + .unwrap() + .is_none()); + assert_eq!(state.tracks_snapshot()[0].title, "Before"); + } +} diff --git a/crates/qbz-qt/qml/controls/TagEditorModal.qml b/crates/qbz-qt/qml/controls/TagEditorModal.qml index 092fb05b4..710c05d0f 100644 --- a/crates/qbz-qt/qml/controls/TagEditorModal.qml +++ b/crates/qbz-qt/qml/controls/TagEditorModal.qml @@ -165,6 +165,14 @@ Item { if (root.visible && !QbzTagEditor.editorLoading) root.seed(root.parse(QbzTagEditor.editorJson)) } + // Rust publishes the immutable document before it clears loading so + // the UI can never observe a ready flag with stale data. Consume the + // document on that second signal as well; otherwise the JSON change is + // deliberately ignored while loading and the modal spins forever. + function onEditorLoadingChanged() { + if (root.visible && !QbzTagEditor.editorLoading) + root.seed(root.parse(QbzTagEditor.editorJson)) + } function onRemoteSeqChanged() { var event = root.parse(QbzTagEditor.remoteJson) if (event.kind === "results") { diff --git a/crates/qbz-qt/qml/views/local/LocalEphemeralPane.qml b/crates/qbz-qt/qml/views/local/LocalEphemeralPane.qml index 7fea04357..d67f65c22 100644 --- a/crates/qbz-qt/qml/views/local/LocalEphemeralPane.qml +++ b/crates/qbz-qt/qml/views/local/LocalEphemeralPane.qml @@ -241,6 +241,21 @@ Item { QbzSession.tr("Play it in a shuffled order", QbzSession.trRev)) } } + QbzCircleAction { + id: editFolderAlbumBtn + visible: !QbzLocal.localSessionIsDisc + && root.allAlbums.length === 1 + && !QbzLocal.localEphemeralLoading + name: "pen-line" + anchors.verticalCenter: parent.verticalCenter + onClicked: QbzLocal.ephemeralEditTags( + root.allAlbums[0].groupKey) + HoverHandler { + onHoveredChanged: tips.hover(hovered, editFolderAlbumBtn, + "eph-edit-album", + QbzSession.tr("Edit metadata", QbzSession.trRev)) + } + } // Fix the names. Offered for both DISC media — a // CD-DA carries no titles at all, and a SACD's Master // TOC can carry the wrong ones ("names itself" and @@ -462,8 +477,7 @@ Item { } } Column { - width: parent.width - 56 - 12 - - (root.eph && root.eph.multiAlbum ? 46 : 0) + width: parent.width - 56 - blockActions.width - 24 anchors.verticalCenter: parent.verticalCenter spacing: 2 Row { @@ -512,11 +526,27 @@ Item { elide: Text.ElideRight } } - QbzCircleAction { - visible: root.eph && root.eph.multiAlbum === true + Row { + id: blockActions anchors.verticalCenter: parent.verticalCenter - name: "play-fill" - onClicked: QbzLocal.ephemeralPlayAlbum(block.modelData.groupKey) + spacing: 8 + QbzCircleAction { + id: editBlockBtn + visible: !QbzLocal.localSessionIsDisc + name: "pen-line" + onClicked: QbzLocal.ephemeralEditTags( + block.modelData.groupKey) + HoverHandler { + onHoveredChanged: tips.hover(hovered, editBlockBtn, + "eph-edit-block", + QbzSession.tr("Edit metadata", QbzSession.trRev)) + } + } + QbzCircleAction { + name: "play-fill" + onClicked: QbzLocal.ephemeralPlayAlbum( + block.modelData.groupKey) + } } } diff --git a/crates/qbz-qt/src/local_bridge.rs b/crates/qbz-qt/src/local_bridge.rs index 945390c16..85b883be9 100644 --- a/crates/qbz-qt/src/local_bridge.rs +++ b/crates/qbz-qt/src/local_bridge.rs @@ -481,6 +481,10 @@ pub mod qbz_local { /// Per-album Play (multi-album sessions only). #[qinvokable] fn ephemeral_play_album(self: Pin<&mut QbzLocal>, group_key: QString); + /// Open the app-wide metadata editor for one physical album directory + /// in the current ephemeral session. + #[qinvokable] + fn ephemeral_edit_tags(self: Pin<&mut QbzLocal>, group_key: QString); /// Track row click: the track's album block becomes the queue. #[qinvokable] fn ephemeral_play_track(self: Pin<&mut QbzLocal>, id: QString); @@ -1503,6 +1507,10 @@ impl qbz_local::QbzLocal { }); } + pub fn ephemeral_edit_tags(self: Pin<&mut Self>, group_key: QString) { + crate::tag_editor_qt::open_ephemeral(group_key.to_string()); + } + pub fn ephemeral_play_track(self: Pin<&mut Self>, id: QString) { let Ok(row) = id.to_string().parse::() else { return; diff --git a/crates/qbz-qt/src/local_ephemeral.rs b/crates/qbz-qt/src/local_ephemeral.rs index 1c208f180..38103fb13 100644 --- a/crates/qbz-qt/src/local_ephemeral.rs +++ b/crates/qbz-qt/src/local_ephemeral.rs @@ -172,6 +172,58 @@ pub(crate) fn album_tracks_for(group_key: &str) -> Vec { album_tracks(group_key) } +/// Snapshot one physical directory for the app-wide metadata editor. +/// +/// The pane splits a multidisc directory into visual blocks, but metadata and +/// its `.qbz.json` sidecar are directory-scoped. Expanding the clicked block +/// back to every row in that directory avoids overwriting a sibling disc's +/// sidecar entries or deleting them after a verified direct write. +pub(crate) fn editor_snapshot(group_key: &str) -> Option<(String, String, Vec)> { + let selected = album_tracks(group_key); + let first = selected.first()?; + let directory = Path::new(&first.file_path).parent()?.to_path_buf(); + if !directory.is_dir() { + return None; + } + let tracks = STATE + .tracks_snapshot() + .into_iter() + .filter(|track| Path::new(&track.file_path).parent() == Some(directory.as_path())) + .collect::>(); + if tracks.is_empty() { + return None; + } + Some(( + STATE.current_folder_path()?, + directory.to_string_lossy().into_owned(), + tracks, + )) +} + +/// Publish metadata edits into the live ephemeral session without renumbering +/// rows already referenced by the queue. The library state performs the +/// session and exact id/path checks atomically before replacing anything. +pub(crate) fn apply_editor_update( + expected_session: &str, + edited: &[LocalTrack], +) -> Result<(), qbz_library::LibraryError> { + let tracks = STATE + .replace_tracks_for_session(expected_session, edited) + .map_err(|error| qbz_library::LibraryError::Metadata(error.to_string()))? + .ok_or_else(|| { + qbz_library::LibraryError::Metadata( + qbz_i18n::t("The ephemeral session changed; reopen the metadata editor."), + ) + })?; + let name = if Path::new(expected_session).is_dir() { + folder_display_name(expected_session) + } else { + expected_session.to_string() + }; + publish_doc(&build_doc(&name, expected_session, &tracks), false); + Ok(()) +} + fn album_tracks(group_key: &str) -> Vec { STATE .tracks_snapshot() diff --git a/crates/qbz-qt/src/tag_editor_qt.rs b/crates/qbz-qt/src/tag_editor_qt.rs index b3469cf5d..60c666898 100644 --- a/crates/qbz-qt/src/tag_editor_qt.rs +++ b/crates/qbz-qt/src/tag_editor_qt.rs @@ -17,6 +17,12 @@ use qbz_library::{ }; use serde::{Deserialize, Serialize}; +#[derive(Clone)] +enum EditorTarget { + Library, + Ephemeral { session_path: String }, +} + #[derive(Clone)] struct EditorSession { generation: u64, @@ -24,6 +30,7 @@ struct EditorSession { group_key: String, directory: String, tracks: Vec, + target: EditorTarget, } static SESSION: OnceLock>> = OnceLock::new(); @@ -236,17 +243,21 @@ fn build_seed(open: &EditorSession) -> EditorSeed { } } -pub fn open(album_id: String) { +fn open_session( + album_id: String, + group_key: String, + directory: String, + tracks: Vec, + target: EditorTarget, +) { if SAVE_ACTIVE.load(Ordering::Acquire) { return; } - let tracks = crate::local_album_actions::current_version_tracks(); - let group_key = crate::local_album_actions::current_version_dir(); - if tracks.is_empty() || group_key.trim().is_empty() { + if tracks.is_empty() || directory.trim().is_empty() { crate::toast_qt::error(qbz_i18n::t("No local album version is selected.")); return; } - if !Path::new(&group_key).is_dir() { + if !Path::new(&directory).is_dir() { crate::toast_qt::info(qbz_i18n::t( "Metadata editing is available for local file versions only.", )); @@ -257,9 +268,10 @@ pub fn open(album_id: String) { let open = EditorSession { generation, album_id, - group_key: group_key.clone(), - directory: group_key, + group_key, + directory, tracks, + target, }; *session().lock().expect("tag editor session lock") = Some(open.clone()); crate::tag_editor_bridge::ui(|mut bridge| { @@ -275,12 +287,19 @@ pub fn open(album_id: String) { }); crate::spawn(async move { + let started = std::time::Instant::now(); + let row_count = open.tracks.len(); let seed = tokio::task::spawn_blocking(move || build_seed(&open)).await; if OPEN_GEN.load(Ordering::SeqCst) != generation { return; } match seed { Ok(seed) => { + log::info!( + "[qbz-qt][perf] tag editor preflight: {} rows in {:?}", + row_count, + started.elapsed() + ); let json = serde_json::to_string(&seed).unwrap_or_else(|_| "{}".to_string()); crate::tag_editor_bridge::ui(move |mut bridge| { bridge @@ -301,6 +320,36 @@ pub fn open(album_id: String) { }); } +pub fn open(album_id: String) { + let tracks = crate::local_album_actions::current_version_tracks(); + let group_key = crate::local_album_actions::current_version_dir(); + open_session( + album_id, + group_key.clone(), + group_key, + tracks, + EditorTarget::Library, + ); +} + +pub fn open_ephemeral(group_key: String) { + let Some((session_path, directory, tracks)) = + crate::local_ephemeral::editor_snapshot(&group_key) + else { + crate::toast_qt::info(qbz_i18n::t( + "Metadata editing is available for local file versions only.", + )); + return; + }; + open_session( + format!("ephemeral:{group_key}"), + directory.clone(), + directory, + tracks, + EditorTarget::Ephemeral { session_path }, + ); +} + pub fn close() { if SAVE_ACTIVE.load(Ordering::Acquire) { return; @@ -487,7 +536,9 @@ fn validate_draft(draft: SaveDraft, open: EditorSession) -> Result Result, qbz_library::LibraryError> { +fn apply_database_update( + payload: &SavePayload, +) -> Result, qbz_library::LibraryError> { let path = crate::local_state::db_path() .ok_or_else(|| qbz_library::LibraryError::Database("library path unavailable".to_string()))?; let mut db = qbz_library::LibraryDatabase::open(&path)?; @@ -504,6 +555,50 @@ fn apply_database_update(payload: &SavePayload) -> Result, qbz_l db.get_album_tracks(&payload.session.group_key) } +fn updated_ephemeral_tracks(payload: &SavePayload) -> Vec { + let updates = payload + .db_updates + .iter() + .map(|update| (update.id, update)) + .collect::>(); + payload + .session + .tracks + .iter() + .cloned() + .map(|mut track| { + let update = updates + .get(&track.id) + .expect("validated ephemeral metadata row set"); + track.title = update.title.clone(); + track.track_number = update.track_number; + track.disc_number = update.disc_number; + track.album = payload.album.album_title.clone(); + track.album_group_title = payload.album.album_title.clone(); + track.album_artist = (!payload.album.album_artist.trim().is_empty()) + .then(|| payload.album.album_artist.clone()); + if payload.prior_artist.as_deref() == Some(track.artist.as_str()) + && !payload.album.album_artist.trim().is_empty() + { + track.artist = payload.album.album_artist.clone(); + } + track.year = payload.album.year; + track.genre = payload.album.genre.clone(); + track.genres = payload.album.genre.iter().cloned().collect(); + track.catalog_number = payload.album.catalog_number.clone(); + track + }) + .collect() +} + +enum SaveOutcome { + Library { + album_id: String, + tracks: Vec, + }, + Ephemeral, +} + pub fn save(draft_json: &str) { if SAVE_ACTIVE .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire) @@ -563,8 +658,18 @@ pub fn save(draft_json: &str) { &payload.sidecar, )?; } - let tracks = apply_database_update(&payload)?; - Ok::<_, qbz_library::LibraryError>((payload.session.album_id, tracks)) + let outcome = match &payload.session.target { + EditorTarget::Library => SaveOutcome::Library { + album_id: payload.session.album_id.clone(), + tracks: apply_database_update(&payload)?, + }, + EditorTarget::Ephemeral { session_path } => { + let tracks = updated_ephemeral_tracks(&payload); + crate::local_ephemeral::apply_editor_update(session_path, &tracks)?; + SaveOutcome::Ephemeral + } + }; + Ok::<_, qbz_library::LibraryError>(outcome) }) .await .unwrap_or_else(|error| { @@ -583,7 +688,7 @@ pub fn save(draft_json: &str) { bridge.as_mut().set_editor_progress_total(0); }); match result { - Ok((album_id, tracks)) => { + Ok(SaveOutcome::Library { album_id, tracks }) => { // Publish from the authoritative DB rows directly. In metadata // grouping the logical id may change as part of this edit, so // re-querying by the old id would close a successful save. @@ -602,6 +707,12 @@ pub fn save(draft_json: &str) { } crate::toast_qt::success(qbz_i18n::t("Album metadata saved.")); } + Ok(SaveOutcome::Ephemeral) => { + if OPEN_GEN.load(Ordering::SeqCst) == open_generation { + close(); + } + crate::toast_qt::success(qbz_i18n::t("Album metadata saved.")); + } Err(error) => { log::error!("[qbz-qt] metadata save failed: {error}"); crate::toast_qt::error(qbz_i18n::t_args( @@ -750,6 +861,7 @@ mod tests { album_id: "album:test".to_string(), group_key: "/library/album".to_string(), directory: "/library/album".to_string(), + target: EditorTarget::Library, tracks: vec![ LocalTrack { id: 10, @@ -820,6 +932,27 @@ mod tests { assert_eq!(payload.direct_tracks[1].title, "Second"); } + #[test] + fn ephemeral_rows_receive_album_and_track_edits_without_changing_paths() { + let draft: SaveDraft = serde_json::from_str(&draft_json( + r#"[ + {"id":"10","title":"First","trackNumber":"3","discNumber":"2"}, + {"id":"20","title":"Second","trackNumber":"4","discNumber":"2"} + ]"#, + )) + .unwrap(); + let payload = validate_draft(draft, session_fixture()).unwrap(); + let tracks = updated_ephemeral_tracks(&payload); + + assert_eq!(tracks[0].file_path, "/library/album/01.flac"); + assert_eq!(tracks[0].album, "Album"); + assert_eq!(tracks[0].album_artist.as_deref(), Some("Artist")); + assert_eq!(tracks[0].title, "First"); + assert_eq!(tracks[0].track_number, Some(3)); + assert_eq!(tracks[0].disc_number, Some(2)); + assert_eq!(tracks[0].genre.as_deref(), Some("Rock")); + } + #[test] fn injected_rows_or_paths_are_rejected() { let injected_id: SaveDraft = serde_json::from_str(&draft_json( @@ -839,4 +972,12 @@ mod tests { ); assert!(serde_json::from_str::(&injected_path).is_err()); } + + #[test] + fn modal_consumes_seed_when_loading_finishes_after_json_publish() { + let qml = include_str!("../qml/controls/TagEditorModal.qml"); + assert!(qml.contains("function onEditorJsonChanged()")); + assert!(qml.contains("function onEditorLoadingChanged()")); + assert!(qml.contains("!QbzTagEditor.editorLoading")); + } }