src/tui/app/machine/fetch_state.rs

@@ -4,9 +4,9 @@ use std::{
 };
 
 use musichoard::collection::{
-    album::{Album, AlbumMeta},
+    album::AlbumMeta,
     artist::{Artist, ArtistId, ArtistMeta},
-    musicbrainz::{IMusicBrainzRef, MbArtistRef, MbRefOption, Mbid},
+    musicbrainz::{IMusicBrainzRef, MbRefOption, Mbid},
 };
 
 use crate::tui::{
@@ -158,10 +158,21 @@ impl AppMachine<FetchState> {
     ) -> Result<(), FetchError> {
         let requests = match artist.meta.info.musicbrainz {
             MbRefOption::Some(ref arid) => {
-                Self::fetch_albums_requests(&artist.meta.id, arid, &artist.albums)
+                let arid = arid.mbid();
+                let albums = artist.albums.iter();
+                albums
+                    .filter(|album| matches!(album.meta.info.musicbrainz, MbRefOption::None))
+                    .map(|album| {
+                        MbParams::search_release_group(
+                            artist.meta.id.clone(),
+                            arid.clone(),
+                            album.meta.clone(),
+                        )
+                    })
+                    .collect()
             }
             MbRefOption::CannotHaveMbid => VecDeque::new(),
-            MbRefOption::None => Self::fetch_artist_request(&artist.meta),
+            MbRefOption::None => VecDeque::from([MbParams::search_artist(artist.meta.clone())]),
         };
         if requests.is_empty() {
             return Err(FetchError::NothingToFetch);
@@ -169,25 +180,6 @@ impl AppMachine<FetchState> {
         Ok(musicbrainz.submit_background_job(result_sender, requests)?)
     }
 
-    fn fetch_albums_requests(
-        artist: &ArtistId,
-        arid: &MbArtistRef,
-        albums: &[Album],
-    ) -> VecDeque<MbParams> {
-        let arid = arid.mbid();
-        albums
-            .iter()
-            .filter(|album| matches!(album.meta.info.musicbrainz, MbRefOption::None))
-            .map(|album| {
-                MbParams::search_release_group(artist.clone(), arid.clone(), album.meta.clone())
-            })
-            .collect()
-    }
-
-    fn fetch_artist_request(meta: &ArtistMeta) -> VecDeque<MbParams> {
-        VecDeque::from([MbParams::search_artist(meta.clone())])
-    }
-
     fn submit_lookup_artist_job(
         musicbrainz: &dyn IMbJobSender,
         result_sender: ResultSender,

src/tui/app/machine/match_state.rs

@@ -1,8 +1,8 @@
 use std::cmp;
 
 use musichoard::collection::{
-    album::{AlbumInfo, AlbumMeta},
+    album::AlbumMeta,
-    artist::{ArtistInfo, ArtistMeta},
+    artist::{ArtistId, ArtistMeta},
     musicbrainz::{MbRefOption, Mbid},
 };
 
@@ -12,70 +12,64 @@ use crate::tui::{
         AlbumMatches, AppPublicState, AppState, ArtistMatches, IAppInteractMatch, ListOption,
         MatchOption, MatchStateInfo, MatchStatePublic, WidgetState,
     },
-    lib::interface::musicbrainz::api::{Lookup, Match},
+    lib::{
+        interface::musicbrainz::api::{Lookup, Match},
+        IMusicHoard,
+    },
 };
 
-trait GetInfoMeta {
+macro_rules! item_option_artist_set {
-    type InfoType;
-}
-impl GetInfoMeta for ArtistMeta {
-    type InfoType = ArtistInfo;
-}
-impl GetInfoMeta for AlbumMeta {
-    type InfoType = AlbumInfo;
-}
-
-trait GetInfo {
-    type InfoType;
-    fn into_info(self, info: Self::InfoType) -> InfoOption<Self::InfoType>;
-}
-
-enum InfoOption<T> {
-    Info(T),
-    NeedInput,
-}
-
-macro_rules! impl_match_option_artist_into_info {
     ($holder:ident) => {
-        impl GetInfo for MatchOption<$holder<ArtistMeta>> {
+        impl MatchOption<$holder<ArtistMeta>> {
-            type InfoType = ArtistInfo;
+            fn set(
-
+                self,
-            fn into_info(self, mut info: Self::InfoType) -> InfoOption<Self::InfoType> {
+                music_hoard: &mut dyn IMusicHoard,
-                match self {
+                meta: &ArtistMeta,
-                    MatchOption::Some(option) => info.musicbrainz = option.item.info.musicbrainz,
+            ) -> Result<(), musichoard::Error> {
-                    MatchOption::CannotHaveMbid => info.musicbrainz = MbRefOption::CannotHaveMbid,
+                let mut info = meta.info.clone();
-                    MatchOption::ManualInputMbid => return InfoOption::NeedInput,
+                info.musicbrainz = match self {
-                }
+                    MatchOption::Some(m) => m.item.info.musicbrainz,
-                InfoOption::Info(info)
+                    MatchOption::CannotHaveMbid => MbRefOption::CannotHaveMbid,
+                    MatchOption::ManualInputMbid => panic!(),
+                };
+                music_hoard.set_artist_info(&meta.id, info)
             }
         }
     };
 }
 
-impl_match_option_artist_into_info!(Match);
+item_option_artist_set!(Lookup);
-impl_match_option_artist_into_info!(Lookup);
+item_option_artist_set!(Match);
 
-macro_rules! impl_match_option_album_into_info {
+macro_rules! item_option_album_set {
     ($holder:ident) => {
-        impl GetInfo for MatchOption<$holder<AlbumMeta>> {
+        impl MatchOption<$holder<AlbumMeta>> {
-            type InfoType = AlbumInfo;
+            fn set(
-
+                self,
-            fn into_info(self, mut info: Self::InfoType) -> InfoOption<Self::InfoType> {
+                music_hoard: &mut dyn IMusicHoard,
-                match self {
+                artist: &ArtistId,
-                    MatchOption::Some(option) => info = option.item.info,
+                meta: &AlbumMeta,
-                    MatchOption::CannotHaveMbid => info.musicbrainz = MbRefOption::CannotHaveMbid,
+            ) -> Result<(), musichoard::Error> {
-                    MatchOption::ManualInputMbid => return InfoOption::NeedInput,
+                let mut info = meta.info.clone();
-                }
+                (info.musicbrainz, info.primary_type, info.secondary_types) = match self {
-                InfoOption::Info(info)
+                    MatchOption::Some(m) => (
+                        m.item.info.musicbrainz,
+                        m.item.info.primary_type,
+                        m.item.info.secondary_types,
+                    ),
+                    MatchOption::CannotHaveMbid => (MbRefOption::CannotHaveMbid, None, Vec::new()),
+                    MatchOption::ManualInputMbid => panic!(),
+                };
+                music_hoard.set_album_info(artist, &meta.id, info)
             }
         }
     };
 }
 
-impl_match_option_album_into_info!(Match);
+item_option_album_set!(Lookup);
-impl_match_option_album_into_info!(Lookup);
+item_option_album_set!(Match);
 
-impl<T> ListOption<T> {
+impl<T: PartialEq> ListOption<T> {
     fn len(&self) -> usize {
         match self {
             ListOption::Lookup(list) => list.len(),
@@ -96,24 +90,40 @@ impl<T> ListOption<T> {
             ListOption::Search(list) => list.push(MatchOption::ManualInputMbid),
         }
     }
-}
 
-trait ExtractInfo {
+    fn is_manual_input_mbid(&self, index: usize) -> bool {
-    type InfoType;
-    fn extract_info(&mut self, index: usize, info: Self::InfoType) -> InfoOption<Self::InfoType>;
-}
-
-impl<T: GetInfoMeta> ExtractInfo for ListOption<T>
-where
-    MatchOption<Match<T>>: GetInfo<InfoType = T::InfoType>,
-    MatchOption<Lookup<T>>: GetInfo<InfoType = T::InfoType>,
-{
-    type InfoType = T::InfoType;
-
-    fn extract_info(&mut self, index: usize, info: Self::InfoType) -> InfoOption<Self::InfoType> {
         match self {
-            ListOption::Lookup(ref mut list) => list.swap_remove(index).into_info(info),
+            ListOption::Lookup(list) => list.get(index) == Some(&MatchOption::ManualInputMbid),
-            ListOption::Search(ref mut list) => list.swap_remove(index).into_info(info),
+            ListOption::Search(list) => list.get(index) == Some(&MatchOption::ManualInputMbid),
+        }
+    }
+}
+
+impl ListOption<ArtistMeta> {
+    fn set(
+        self,
+        music_hoard: &mut dyn IMusicHoard,
+        meta: &ArtistMeta,
+        index: usize,
+    ) -> Result<(), musichoard::Error> {
+        match self {
+            ListOption::Lookup(mut list) => list.swap_remove(index).set(music_hoard, meta),
+            ListOption::Search(mut list) => list.swap_remove(index).set(music_hoard, meta),
+        }
+    }
+}
+
+impl ListOption<AlbumMeta> {
+    fn set(
+        self,
+        music_hoard: &mut dyn IMusicHoard,
+        artist: &ArtistId,
+        meta: &AlbumMeta,
+        index: usize,
+    ) -> Result<(), musichoard::Error> {
+        match self {
+            ListOption::Lookup(mut list) => list.swap_remove(index).set(music_hoard, artist, meta),
+            ListOption::Search(mut list) => list.swap_remove(index).set(music_hoard, artist, meta),
         }
     }
 }
@@ -130,6 +140,14 @@ impl ArtistMatches {
     fn push_manual_input_mbid(&mut self) {
         self.list.push_manual_input_mbid();
     }
+
+    fn is_manual_input_mbid(&self, index: usize) -> bool {
+        self.list.is_manual_input_mbid(index)
+    }
+
+    fn set(self, music_hoard: &mut dyn IMusicHoard, index: usize) -> Result<(), musichoard::Error> {
+        self.list.set(music_hoard, &self.matching, index)
+    }
 }
 
 impl AlbumMatches {
@@ -144,6 +162,15 @@ impl AlbumMatches {
     fn push_manual_input_mbid(&mut self) {
         self.list.push_manual_input_mbid();
     }
+
+    fn is_manual_input_mbid(&self, index: usize) -> bool {
+        self.list.is_manual_input_mbid(index)
+    }
+
+    fn set(self, music_hoard: &mut dyn IMusicHoard, index: usize) -> Result<(), musichoard::Error> {
+        self.list
+            .set(music_hoard, &self.artist, &self.matching, index)
+    }
 }
 
 impl MatchStateInfo {
@@ -167,6 +194,20 @@ impl MatchStateInfo {
             Self::Album(a) => a.push_manual_input_mbid(),
         }
     }
+
+    fn is_manual_input_mbid(&self, index: usize) -> bool {
+        match self {
+            Self::Artist(a) => a.is_manual_input_mbid(index),
+            Self::Album(a) => a.is_manual_input_mbid(index),
+        }
+    }
+
+    fn set(self, music_hoard: &mut dyn IMusicHoard, index: usize) -> Result<(), musichoard::Error> {
+        match self {
+            Self::Artist(a) => a.set(music_hoard, index),
+            Self::Album(a) => a.set(music_hoard, index),
+        }
+    }
 }
 
 pub struct MatchState {
@@ -219,11 +260,6 @@ impl AppMachine<MatchState> {
             }
         }
     }
-
-    fn get_input(mut self) -> App {
-        self.input.replace(Input::default());
-        self.into()
-    }
 }
 
 impl From<AppMachine<MatchState>> for App {
@@ -271,27 +307,23 @@ impl IAppInteractMatch for AppMachine<MatchState> {
         if let Some(index) = self.state.state.list.selected() {
             // selected() implies current exists
 
-            let mh = &mut self.inner.music_hoard;
+            if self
-            let result = match self.state.current.as_mut().unwrap() {
+                .state
-                MatchStateInfo::Artist(ref mut matches) => {
+                .current
-                    let info: ArtistInfo = matches.matching.info.clone();
+                .as_ref()
-                    match matches.list.extract_info(index, info) {
+                .unwrap()
-                        InfoOption::Info(info) => mh.set_artist_info(&matches.matching.id, info),
+                .is_manual_input_mbid(index)
-                        InfoOption::NeedInput => return self.get_input(),
+            {
-                    }
+                self.input.replace(Input::default());
-                }
+                return self.into();
-                MatchStateInfo::Album(matches) => {
+            }
-                    let info: AlbumInfo = matches.matching.info.clone();
-                    match matches.list.extract_info(index, info) {
-                        InfoOption::Info(info) => {
-                            mh.set_album_info(&matches.artist, &matches.matching.id, info)
-                        }
-                        InfoOption::NeedInput => return self.get_input(),
-                    }
-                }
-            };
 
-            if let Err(err) = result {
+            if let Err(err) = self
+                .state
+                .current
+                .unwrap()
+                .set(&mut *self.inner.music_hoard, index)
+            {
                 return AppMachine::error_state(self.inner, err.to_string()).into();
             }
         }