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")); + } }