wojtek/musichoard
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects 1 Releases 2 Wiki Activity

Compare commits

base: wojtek:b01af5ff18b7b077e30a1ac2f8276b1235147283
Branches Tags
wojtek:main
wojtek:160---provide-a-keyboard-shortcut-to-pull-all-release-groups-of-an-artist
wojtek:v0.2.0
wojtek:v0.1.0
..
compare: wojtek:898d2e1469041e302e1a2b909d7f90e58b227f78
Branches Tags
wojtek:160---provide-a-keyboard-shortcut-to-pull-all-release-groups-of-an-artist
wojtek:main
wojtek:v0.2.0
wojtek:v0.1.0

No commits in common. "b01af5ff18b7b077e30a1ac2f8276b1235147283" and "898d2e1469041e302e1a2b909d7f90e58b227f78" have entirely different histories.
b01af5ff18 ... 898d2e1469

13 changed files with 116 additions and 234 deletions
Show Stats Expand all files Collapse all files

2
examples/musicbrainz_api/browse.rs
View File

@ -72,7 +72,7 @@ fn main() {
println!("Release groups in this response: {count}"); println!("Release groups in this response: {count}");
match response.page.next_page_offset(count) { match response.page.next_page_offset(count) {
NextPage::Offset(next_offset) => paging.set_offset(next_offset), NextPage::Offset(next_offset) => paging.with_offset(next_offset),
NextPage::Complete => break, NextPage::Complete => break,
} }

17
src/external/musicbrainz/api/mod.rs vendored
View File

@ -61,7 +61,7 @@ impl<Http> MusicBrainzClient<Http> {
} }
} }
#[derive(Debug, Default)] #[derive(Default)]
pub struct PageSettings { pub struct PageSettings {
limit: Option<usize>, limit: Option<usize>,
offset: Option<usize>, offset: Option<usize>,
@ -79,12 +79,7 @@ impl PageSettings {
Self::with_limit(MB_MAX_PAGE_LIMIT) Self::with_limit(MB_MAX_PAGE_LIMIT)
} }
pub fn with_offset(mut self, offset: usize) -> Self { pub fn with_offset(&mut self, offset: usize) {
self.offset = Some(offset);
self
}
pub fn set_offset(&mut self, offset: usize) {
self.offset = Some(offset); self.offset = Some(offset);
} }
} }
@ -96,10 +91,6 @@ pub enum NextPage {
} }
impl NextPage { impl NextPage {
pub fn new() -> NextPage {
NextPage::Offset(0)
}
pub fn next_page_offset(offset: usize, total_count: usize, page_count: usize) -> NextPage { pub fn next_page_offset(offset: usize, total_count: usize, page_count: usize) -> NextPage {
let next_offset = offset + page_count; let next_offset = offset + page_count;
if next_offset < total_count { if next_offset < total_count {
@ -396,14 +387,14 @@ mod tests {
assert_eq!(ApiDisplay::format_page_settings(&paging), "&limit=100"); assert_eq!(ApiDisplay::format_page_settings(&paging), "&limit=100");
let mut paging = PageSettings::with_limit(45); let mut paging = PageSettings::with_limit(45);
paging.set_offset(145); paging.with_offset(145);
assert_eq!( assert_eq!(
ApiDisplay::format_page_settings(&paging), ApiDisplay::format_page_settings(&paging),
"&limit=45&offset=145" "&limit=45&offset=145"
); );
let mut paging = PageSettings::default(); let mut paging = PageSettings::default();
paging.set_offset(26); paging.with_offset(26);
assert_eq!(ApiDisplay::format_page_settings(&paging), "&offset=26"); assert_eq!(ApiDisplay::format_page_settings(&paging), "&offset=26");
} }

33
src/tui/app/machine/fetch_state.rs
View File

@ -16,7 +16,7 @@ use crate::tui::{
AppPublicState, AppState, Category, IAppEventFetch, IAppInteractFetch, AppPublicState, AppState, Category, IAppEventFetch, IAppInteractFetch,
}, },
lib::interface::musicbrainz::daemon::{ lib::interface::musicbrainz::daemon::{
Error as DaemonError, IMbJobSender, MbApiResult, MbParams, MbReturn, ResultSender, Error as DaemonError, IMbJobSender, MbApiResult, MbParams, ResultSender,
}, },
}; };
@ -116,7 +116,9 @@ impl AppMachine<FetchState> {
pub fn app_fetch_next(inner: AppInner, mut fetch: FetchState) -> App { pub fn app_fetch_next(inner: AppInner, mut fetch: FetchState) -> App {
match fetch.try_recv() { match fetch.try_recv() {
Ok(fetch_result) => match fetch_result { Ok(fetch_result) => match fetch_result {
Ok(retval) => Self::handle_mb_api_return(inner, fetch, retval), Ok(next_match) => {
AppMachine::match_state(inner, MatchState::new(next_match, fetch)).into()
}
Err(fetch_err) => { Err(fetch_err) => {
AppMachine::error_state(inner, format!("fetch failed: {fetch_err}")).into() AppMachine::error_state(inner, format!("fetch failed: {fetch_err}")).into()
} }
@ -128,15 +130,6 @@ impl AppMachine<FetchState> {
} }
} }
fn handle_mb_api_return(inner: AppInner, fetch: FetchState, retval: MbReturn) -> App {
match retval {
MbReturn::Match(next_match) => {
AppMachine::match_state(inner, MatchState::new(next_match, fetch)).into()
}
_ => unimplemented!(),
}
}
pub fn app_lookup_artist( pub fn app_lookup_artist(
inner: AppInner, inner: AppInner,
fetch: FetchState, fetch: FetchState,
@ -295,7 +288,7 @@ mod tests {
use crate::tui::{ use crate::tui::{
app::{ app::{
machine::tests::{inner, music_hoard}, machine::tests::{inner, music_hoard},
Delta, EntityMatches, IApp, IAppAccess, IAppInteractBrowse, MatchOption, Delta, IApp, IAppAccess, IAppInteractBrowse, MatchOption, MatchStateInfo,
}, },
lib::interface::musicbrainz::{self, api::Entity, daemon::MockIMbJobSender}, lib::interface::musicbrainz::{self, api::Entity, daemon::MockIMbJobSender},
testmod::COLLECTION, testmod::COLLECTION,
@ -318,13 +311,13 @@ mod tests {
let artist = COLLECTION[3].meta.clone(); let artist = COLLECTION[3].meta.clone();
let matches: Vec<Entity<ArtistMeta>> = vec![]; let matches: Vec<Entity<ArtistMeta>> = vec![];
let fetch_result = MbReturn::Match(EntityMatches::artist_search(artist.clone(), matches)); let fetch_result = MatchStateInfo::artist_search(artist.clone(), matches);
fetch_tx.send(Ok(fetch_result.clone())).unwrap(); fetch_tx.send(Ok(fetch_result.clone())).unwrap();
assert_eq!(fetch.try_recv(), Err(TryRecvError::Empty)); assert_eq!(fetch.try_recv(), Err(TryRecvError::Empty));
let lookup = Entity::new(artist.clone()); let lookup = Entity::new(artist.clone());
let lookup_result = MbReturn::Match(EntityMatches::artist_lookup(artist.clone(), lookup)); let lookup_result = MatchStateInfo::artist_lookup(artist.clone(), lookup);
lookup_tx.send(Ok(lookup_result.clone())).unwrap(); lookup_tx.send(Ok(lookup_result.clone())).unwrap();
assert_eq!(fetch.try_recv(), Ok(Ok(lookup_result))); assert_eq!(fetch.try_recv(), Ok(Ok(lookup_result)));
@ -610,8 +603,8 @@ mod tests {
let artist = COLLECTION[3].meta.clone(); let artist = COLLECTION[3].meta.clone();
let artist_match = Entity::with_score(COLLECTION[2].meta.clone(), 80); let artist_match = Entity::with_score(COLLECTION[2].meta.clone(), 80);
let artist_match_info = let artist_match_info =
EntityMatches::artist_search(artist.clone(), vec![artist_match.clone()]); MatchStateInfo::artist_search(artist.clone(), vec![artist_match.clone()]);
let fetch_result = Ok(MbReturn::Match(artist_match_info)); let fetch_result = Ok(artist_match_info);
tx.send(fetch_result).unwrap(); tx.send(fetch_result).unwrap();
let inner = inner(music_hoard(COLLECTION.clone())); let inner = inner(music_hoard(COLLECTION.clone()));
@ -626,8 +619,8 @@ mod tests {
MatchOption::CannotHaveMbid, MatchOption::CannotHaveMbid,
MatchOption::ManualInputMbid, MatchOption::ManualInputMbid,
]; ];
let expected = EntityMatches::artist_search(artist, match_options); let expected = MatchStateInfo::artist_search(artist, match_options);
assert_eq!(match_state.matches, &expected); assert_eq!(match_state.info, &expected);
} }
#[test] #[test]
@ -684,8 +677,8 @@ mod tests {
assert!(matches!(app, AppState::Fetch(_))); assert!(matches!(app, AppState::Fetch(_)));
let artist = COLLECTION[3].meta.clone(); let artist = COLLECTION[3].meta.clone();
let match_info = EntityMatches::artist_search::<Entity<ArtistMeta>>(artist, vec![]); let match_info = MatchStateInfo::artist_search::<Entity<ArtistMeta>>(artist, vec![]);
let fetch_result = Ok(MbReturn::Match(match_info)); let fetch_result = Ok(match_info);
tx.send(fetch_result).unwrap(); tx.send(fetch_result).unwrap();
let app = app.unwrap_fetch().fetch_result_ready(); let app = app.unwrap_fetch().fetch_result_ready();

62
src/tui/app/machine/match_state.rs
View File

@ -8,8 +8,8 @@ use musichoard::collection::{
use crate::tui::app::{ use crate::tui::app::{
machine::{fetch_state::FetchState, input::Input, App, AppInner, AppMachine}, machine::{fetch_state::FetchState, input::Input, App, AppInner, AppMachine},
AlbumMatches, AppPublicState, AppState, ArtistMatches, Delta, EntityMatches, IAppInteractMatch, AlbumMatches, AppPublicState, AppState, ArtistMatches, Delta, IAppInteractMatch, MatchOption,
MatchOption, MatchStatePublic, WidgetState, MatchStateInfo, MatchStatePublic, WidgetState,
}; };
trait GetInfoMeta { trait GetInfoMeta {
@ -103,7 +103,7 @@ impl AlbumMatches {
} }
} }
impl EntityMatches { impl MatchStateInfo {
fn len(&self) -> usize { fn len(&self) -> usize {
match self { match self {
Self::Artist(a) => a.len(), Self::Artist(a) => a.len(),
@ -127,13 +127,13 @@ impl EntityMatches {
} }
pub struct MatchState { pub struct MatchState {
current: EntityMatches, current: MatchStateInfo,
state: WidgetState, state: WidgetState,
fetch: FetchState, fetch: FetchState,
} }
impl MatchState { impl MatchState {
pub fn new(mut current: EntityMatches, fetch: FetchState) -> Self { pub fn new(mut current: MatchStateInfo, fetch: FetchState) -> Self {
current.push_cannot_have_mbid(); current.push_cannot_have_mbid();
current.push_manual_input_mbid(); current.push_manual_input_mbid();
@ -158,11 +158,11 @@ impl AppMachine<MatchState> {
Err(err) => return AppMachine::error_state(self.inner, err.to_string()).into(), Err(err) => return AppMachine::error_state(self.inner, err.to_string()).into(),
}; };
match self.state.current { match self.state.current {
EntityMatches::Artist(artist_matches) => { MatchStateInfo::Artist(artist_matches) => {
let matching = &artist_matches.matching; let matching = &artist_matches.matching;
AppMachine::app_lookup_artist(self.inner, self.state.fetch, matching, mbid) AppMachine::app_lookup_artist(self.inner, self.state.fetch, matching, mbid)
} }
EntityMatches::Album(album_matches) => { MatchStateInfo::Album(album_matches) => {
let artist_id = &album_matches.artist; let artist_id = &album_matches.artist;
let matching = &album_matches.matching; let matching = &album_matches.matching;
AppMachine::app_lookup_album( AppMachine::app_lookup_album(
@ -191,7 +191,7 @@ impl From<AppMachine<MatchState>> for App {
impl<'a> From<&'a mut MatchState> for AppPublicState<'a> { impl<'a> From<&'a mut MatchState> for AppPublicState<'a> {
fn from(state: &'a mut MatchState) -> Self { fn from(state: &'a mut MatchState) -> Self {
AppState::Match(MatchStatePublic { AppState::Match(MatchStatePublic {
matches: &state.current, info: &state.current,
state: &mut state.state, state: &mut state.state,
}) })
} }
@ -225,14 +225,14 @@ impl IAppInteractMatch for AppMachine<MatchState> {
let mh = &mut self.inner.music_hoard; let mh = &mut self.inner.music_hoard;
let result = match self.state.current { let result = match self.state.current {
EntityMatches::Artist(ref mut matches) => { MatchStateInfo::Artist(ref mut matches) => {
let info: ArtistInfo = matches.matching.info.clone(); let info: ArtistInfo = matches.matching.info.clone();
match matches.list.extract_info(index, info) { match matches.list.extract_info(index, info) {
InfoOption::Info(info) => mh.set_artist_info(&matches.matching.id, info), InfoOption::Info(info) => mh.set_artist_info(&matches.matching.id, info),
InfoOption::NeedInput => return self.get_input(), InfoOption::NeedInput => return self.get_input(),
} }
} }
EntityMatches::Album(ref mut matches) => { MatchStateInfo::Album(ref mut matches) => {
let info: AlbumInfo = matches.matching.info.clone(); let info: AlbumInfo = matches.matching.info.clone();
match matches.list.extract_info(index, info) { match matches.list.extract_info(index, info) {
InfoOption::Info(info) => { InfoOption::Info(info) => {
@ -298,7 +298,7 @@ mod tests {
meta meta
} }
fn artist_match() -> EntityMatches { fn artist_match() -> MatchStateInfo {
let artist = artist_meta(); let artist = artist_meta();
let artist_1 = artist.clone(); let artist_1 = artist.clone();
@ -309,13 +309,13 @@ mod tests {
artist_match_2.disambiguation = Some(String::from("some disambiguation")); artist_match_2.disambiguation = Some(String::from("some disambiguation"));
let list = vec![artist_match_1.clone(), artist_match_2.clone()]; let list = vec![artist_match_1.clone(), artist_match_2.clone()];
EntityMatches::artist_search(artist, list) MatchStateInfo::artist_search(artist, list)
} }
fn artist_lookup() -> EntityMatches { fn artist_lookup() -> MatchStateInfo {
let artist = artist_meta(); let artist = artist_meta();
let lookup = Entity::new(artist.clone()); let lookup = Entity::new(artist.clone());
EntityMatches::artist_lookup(artist, lookup) MatchStateInfo::artist_lookup(artist, lookup)
} }
fn album_meta() -> AlbumMeta { fn album_meta() -> AlbumMeta {
@ -330,7 +330,7 @@ mod tests {
) )
} }
fn album_match() -> EntityMatches { fn album_match() -> MatchStateInfo {
let artist_id = ArtistId::new("Artist"); let artist_id = ArtistId::new("Artist");
let album = album_meta(); let album = album_meta();
@ -343,14 +343,14 @@ mod tests {
let album_match_2 = Entity::with_score(album_2, 100); let album_match_2 = Entity::with_score(album_2, 100);
let list = vec![album_match_1.clone(), album_match_2.clone()]; let list = vec![album_match_1.clone(), album_match_2.clone()];
EntityMatches::album_search(artist_id, album, list) MatchStateInfo::album_search(artist_id, album, list)
} }
fn album_lookup() -> EntityMatches { fn album_lookup() -> MatchStateInfo {
let artist_id = ArtistId::new("Artist"); let artist_id = ArtistId::new("Artist");
let album = album_meta(); let album = album_meta();
let lookup = Entity::new(album.clone()); let lookup = Entity::new(album.clone());
EntityMatches::album_lookup(artist_id, album, lookup) MatchStateInfo::album_lookup(artist_id, album, lookup)
} }
fn fetch_state() -> FetchState { fn fetch_state() -> FetchState {
@ -358,7 +358,7 @@ mod tests {
FetchState::new(rx) FetchState::new(rx)
} }
fn match_state(match_state_info: EntityMatches) -> MatchState { fn match_state(match_state_info: MatchStateInfo) -> MatchState {
MatchState::new(match_state_info, fetch_state()) MatchState::new(match_state_info, fetch_state())
} }
@ -379,11 +379,11 @@ mod tests {
let public = app.get(); let public = app.get();
let public_matches = public.state.unwrap_match(); let public_matches = public.state.unwrap_match();
assert_eq!(public_matches.matches, &album_match); assert_eq!(public_matches.info, &album_match);
assert_eq!(public_matches.state, &widget_state); assert_eq!(public_matches.state, &widget_state);
} }
fn match_state_flow(mut matches_info: EntityMatches, len: usize) { fn match_state_flow(mut matches_info: MatchStateInfo, len: usize) {
// tx must exist for rx to return Empty rather than Disconnected. // tx must exist for rx to return Empty rather than Disconnected.
let (_tx, rx) = mpsc::channel(); let (_tx, rx) = mpsc::channel();
let app_matches = MatchState::new(matches_info.clone(), FetchState::new(rx)); let app_matches = MatchState::new(matches_info.clone(), FetchState::new(rx));
@ -391,7 +391,7 @@ mod tests {
let mut music_hoard = music_hoard(vec![]); let mut music_hoard = music_hoard(vec![]);
let artist_id = ArtistId::new("Artist"); let artist_id = ArtistId::new("Artist");
match matches_info { match matches_info {
EntityMatches::Album(_) => { MatchStateInfo::Album(_) => {
let album_id = AlbumId::new("Album"); let album_id = AlbumId::new("Album");
let mut info = album_meta().info; let mut info = album_meta().info;
info.musicbrainz = MbRefOption::CannotHaveMbid; info.musicbrainz = MbRefOption::CannotHaveMbid;
@ -401,7 +401,7 @@ mod tests {
.times(1) .times(1)
.return_once(|_, _, _| Ok(())); .return_once(|_, _, _| Ok(()));
} }
EntityMatches::Artist(_) => { MatchStateInfo::Artist(_) => {
let mut info = artist_meta().info; let mut info = artist_meta().info;
info.musicbrainz = MbRefOption::CannotHaveMbid; info.musicbrainz = MbRefOption::CannotHaveMbid;
music_hoard music_hoard
@ -485,8 +485,8 @@ mod tests {
let mut music_hoard = music_hoard(vec![]); let mut music_hoard = music_hoard(vec![]);
match matches_info { match matches_info {
EntityMatches::Album(_) => panic!(), MatchStateInfo::Album(_) => panic!(),
EntityMatches::Artist(_) => { MatchStateInfo::Artist(_) => {
let meta = artist_meta(); let meta = artist_meta();
music_hoard music_hoard
.expect_set_artist_info() .expect_set_artist_info()
@ -509,8 +509,8 @@ mod tests {
let mut music_hoard = music_hoard(vec![]); let mut music_hoard = music_hoard(vec![]);
match matches_info { match matches_info {
EntityMatches::Artist(_) => panic!(), MatchStateInfo::Artist(_) => panic!(),
EntityMatches::Album(matches) => { MatchStateInfo::Album(matches) => {
let meta = album_meta(); let meta = album_meta();
music_hoard music_hoard
.expect_set_album_info() .expect_set_album_info()
@ -533,8 +533,8 @@ mod tests {
let mut music_hoard = music_hoard(vec![]); let mut music_hoard = music_hoard(vec![]);
match matches_info { match matches_info {
EntityMatches::Album(_) => panic!(), MatchStateInfo::Album(_) => panic!(),
EntityMatches::Artist(_) => { MatchStateInfo::Artist(_) => {
music_hoard.expect_set_artist_info().return_once(|_, _| { music_hoard.expect_set_artist_info().return_once(|_, _| {
Err(musichoard::Error::DatabaseError(String::from("error"))) Err(musichoard::Error::DatabaseError(String::from("error")))
}); });
@ -598,7 +598,7 @@ mod tests {
.return_once(|_, _| Ok(())); .return_once(|_, _| Ok(()));
let matches_vec: Vec<Entity<ArtistMeta>> = vec![]; let matches_vec: Vec<Entity<ArtistMeta>> = vec![];
let artist_match = EntityMatches::artist_search(artist.clone(), matches_vec); let artist_match = MatchStateInfo::artist_search(artist.clone(), matches_vec);
let matches = AppMachine::match_state( let matches = AppMachine::match_state(
inner_with_mb(music_hoard(vec![]), mb_job_sender), inner_with_mb(music_hoard(vec![]), mb_job_sender),
match_state(artist_match), match_state(artist_match),
@ -632,7 +632,7 @@ mod tests {
let matches_vec: Vec<Entity<AlbumMeta>> = vec![]; let matches_vec: Vec<Entity<AlbumMeta>> = vec![];
let album_match = let album_match =
EntityMatches::album_search(artist_id.clone(), album.clone(), matches_vec); MatchStateInfo::album_search(artist_id.clone(), album.clone(), matches_vec);
let matches = AppMachine::match_state( let matches = AppMachine::match_state(
inner_with_mb(music_hoard(vec![]), mb_job_sender), inner_with_mb(music_hoard(vec![]), mb_job_sender),
match_state(album_match), match_state(album_match),

4
src/tui/app/machine/mod.rs
View File

@ -225,7 +225,7 @@ mod tests {
}; };
use crate::tui::{ use crate::tui::{
app::{AppState, EntityMatches, IApp, IAppInput, IAppInteractBrowse, InputEvent}, app::{AppState, IApp, IAppInput, IAppInteractBrowse, InputEvent, MatchStateInfo},
lib::{ lib::{
interface::musicbrainz::{api::Entity, daemon::MockIMbJobSender}, interface::musicbrainz::{api::Entity, daemon::MockIMbJobSender},
MockIMusicHoard, MockIMusicHoard,
@ -520,7 +520,7 @@ mod tests {
let (_, rx) = mpsc::channel(); let (_, rx) = mpsc::channel();
let fetch = FetchState::new(rx); let fetch = FetchState::new(rx);
let artist = ArtistMeta::new(ArtistId::new("Artist")); let artist = ArtistMeta::new(ArtistId::new("Artist"));
let info = EntityMatches::artist_lookup(artist.clone(), Entity::new(artist.clone())); let info = MatchStateInfo::artist_lookup(artist.clone(), Entity::new(artist.clone()));
app = app =
AppMachine::match_state(app.unwrap_browse().inner, MatchState::new(info, fetch)).into(); AppMachine::match_state(app.unwrap_browse().inner, MatchState::new(info, fetch)).into();

14
src/tui/app/mod.rs
View File

@ -240,18 +240,18 @@ pub struct AlbumMatches {
} }
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum EntityMatches { pub enum MatchStateInfo {
Artist(ArtistMatches), Artist(ArtistMatches),
Album(AlbumMatches), Album(AlbumMatches),
} }
impl EntityMatches { impl MatchStateInfo {
pub fn artist_search<M: Into<MatchOption<ArtistMeta>>>( pub fn artist_search<M: Into<MatchOption<ArtistMeta>>>(
matching: ArtistMeta, matching: ArtistMeta,
list: Vec<M>, list: Vec<M>,
) -> Self { ) -> Self {
let list = list.into_iter().map(Into::into).collect(); let list = list.into_iter().map(Into::into).collect();
EntityMatches::Artist(ArtistMatches { matching, list }) MatchStateInfo::Artist(ArtistMatches { matching, list })
} }
pub fn album_search<M: Into<MatchOption<AlbumMeta>>>( pub fn album_search<M: Into<MatchOption<AlbumMeta>>>(
@ -260,7 +260,7 @@ impl EntityMatches {
list: Vec<M>, list: Vec<M>,
) -> Self { ) -> Self {
let list = list.into_iter().map(Into::into).collect(); let list = list.into_iter().map(Into::into).collect();
EntityMatches::Album(AlbumMatches { MatchStateInfo::Album(AlbumMatches {
artist, artist,
matching, matching,
list, list,
@ -269,7 +269,7 @@ impl EntityMatches {
pub fn artist_lookup<M: Into<MatchOption<ArtistMeta>>>(matching: ArtistMeta, item: M) -> Self { pub fn artist_lookup<M: Into<MatchOption<ArtistMeta>>>(matching: ArtistMeta, item: M) -> Self {
let list = vec![item.into()]; let list = vec![item.into()];
EntityMatches::Artist(ArtistMatches { matching, list }) MatchStateInfo::Artist(ArtistMatches { matching, list })
} }
pub fn album_lookup<M: Into<MatchOption<AlbumMeta>>>( pub fn album_lookup<M: Into<MatchOption<AlbumMeta>>>(
@ -278,7 +278,7 @@ impl EntityMatches {
item: M, item: M,
) -> Self { ) -> Self {
let list = vec![item.into()]; let list = vec![item.into()];
EntityMatches::Album(AlbumMatches { MatchStateInfo::Album(AlbumMatches {
artist, artist,
matching, matching,
list, list,
@ -287,7 +287,7 @@ impl EntityMatches {
} }
pub struct MatchStatePublic<'app> { pub struct MatchStatePublic<'app> {
pub matches: &'app EntityMatches, pub info: &'app MatchStateInfo,
pub state: &'app mut WidgetState, pub state: &'app mut WidgetState,
} }

120
src/tui/lib/external/musicbrainz/daemon/mod.rs vendored
View File

@ -1,16 +1,11 @@
use std::{collections::VecDeque, sync::mpsc, thread, time}; use std::{collections::VecDeque, sync::mpsc, thread, time};
use musichoard::external::musicbrainz::api::{NextPage, PageSettings};
use crate::tui::{ use crate::tui::{
app::EntityMatches, app::MatchStateInfo,
event::IFetchCompleteEventSender, event::IFetchCompleteEventSender,
lib::interface::musicbrainz::{ lib::interface::musicbrainz::{
api::{Error as ApiError, IMusicBrainz, Paged}, api::{Error as ApiError, IMusicBrainz},
daemon::{ daemon::{Error, IMbJobSender, LookupParams, MbParams, ResultSender, SearchParams},
BrowseParams, EntityList, Error, IMbJobSender, LookupParams, MbParams, MbReturn,
ResultSender, SearchParams,
},
}, },
}; };
@ -48,7 +43,6 @@ enum JobPriority {
struct JobInstance { struct JobInstance {
result_sender: ResultSender, result_sender: ResultSender,
requests: VecDeque<MbParams>, requests: VecDeque<MbParams>,
paging: Option<PageSettings>,
} }
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq)]
@ -68,7 +62,6 @@ impl JobInstance {
JobInstance { JobInstance {
result_sender, result_sender,
requests, requests,
paging: None,
} }
} }
} }
@ -228,17 +221,8 @@ impl JobInstance {
event_sender: &mut dyn IFetchCompleteEventSender, event_sender: &mut dyn IFetchCompleteEventSender,
) -> Result<JobInstanceStatus, JobInstanceError> { ) -> Result<JobInstanceStatus, JobInstanceError> {
// self.requests can be empty if the caller submits an empty job. // self.requests can be empty if the caller submits an empty job.
self.paging = match self.requests.front() { if let Some(params) = self.requests.pop_front() {
Some(params) => { self.execute(musicbrainz, event_sender, params)?
let result_sender = &mut self.result_sender;
let paging = self.paging.take();
Self::execute(musicbrainz, result_sender, event_sender, &params, paging)?
}
None => None,
};
if self.paging.is_none() {
self.requests.pop_front();
} }
if self.requests.is_empty() { if self.requests.is_empty() {
@ -249,64 +233,38 @@ impl JobInstance {
} }
fn execute( fn execute(
&mut self,
musicbrainz: &mut dyn IMusicBrainz, musicbrainz: &mut dyn IMusicBrainz,
result_sender: &mut ResultSender,
event_sender: &mut dyn IFetchCompleteEventSender, event_sender: &mut dyn IFetchCompleteEventSender,
api_params: &MbParams, api_params: MbParams,
paging: Option<PageSettings>, ) -> Result<(), JobInstanceError> {
) -> Result<Option<PageSettings>, JobInstanceError> {
let mut paging = match paging {
Some(paging) => paging,
None => PageSettings::with_max_limit(),
};
let mut next_page = NextPage::Complete;
let result = match api_params { let result = match api_params {
MbParams::Lookup(lookup) => match lookup { MbParams::Lookup(lookup) => match lookup {
LookupParams::Artist(p) => musicbrainz LookupParams::Artist(params) => musicbrainz
.lookup_artist(&p.mbid) .lookup_artist(&params.mbid)
.map(|rv| EntityMatches::artist_lookup(p.artist.clone(), rv)), .map(|rv| MatchStateInfo::artist_lookup(params.artist, rv)),
LookupParams::ReleaseGroup(p) => { LookupParams::ReleaseGroup(params) => musicbrainz
musicbrainz.lookup_release_group(&p.mbid).map(|rv| { .lookup_release_group(&params.mbid)
EntityMatches::album_lookup(p.artist_id.clone(), p.album.clone(), rv) .map(|rv| MatchStateInfo::album_lookup(params.artist_id, params.album, rv)),
}) },
}
}
.map(MbReturn::Match),
MbParams::Search(search) => match search { MbParams::Search(search) => match search {
SearchParams::Artist(p) => musicbrainz SearchParams::Artist(params) => musicbrainz
.search_artist(&p.artist) .search_artist(&params.artist)
.map(|rv| EntityMatches::artist_search(p.artist.clone(), rv)), .map(|rv| MatchStateInfo::artist_search(params.artist, rv)),
SearchParams::ReleaseGroup(p) => musicbrainz SearchParams::ReleaseGroup(params) => musicbrainz
.search_release_group(&p.artist_mbid, &p.album) .search_release_group(&params.artist_mbid, &params.album)
.map(|rv| { .map(|rv| MatchStateInfo::album_search(params.artist_id, params.album, rv)),
EntityMatches::album_search(p.artist_id.clone(), p.album.clone(), rv) },
}),
}
.map(MbReturn::Match),
MbParams::Browse(browse) => match browse {
BrowseParams::ReleaseGroup(params) => Paged::map_paged_result(
musicbrainz.browse_release_group(&params.artist, &mut paging),
|ents| EntityList::Album(ents.into_iter().map(|rg| rg.entity).collect()),
&mut next_page,
),
}
.map(MbReturn::Fetch),
}; };
Self::return_result(result_sender, event_sender, result)?; self.return_result(event_sender, result)
Ok(match next_page {
NextPage::Offset(offset) => Some(paging.with_offset(offset)),
NextPage::Complete => None,
})
} }
fn return_result( fn return_result(
result_sender: &mut ResultSender, &mut self,
event_sender: &mut dyn IFetchCompleteEventSender, event_sender: &mut dyn IFetchCompleteEventSender,
result: Result<MbReturn, ApiError>, result: Result<MatchStateInfo, ApiError>,
) -> Result<(), JobInstanceError> { ) -> Result<(), JobInstanceError> {
result_sender self.result_sender
.send(result) .send(result)
.map_err(|_| JobInstanceError::ReturnChannelDisconnected)?; .map_err(|_| JobInstanceError::ReturnChannelDisconnected)?;
@ -617,12 +575,7 @@ mod tests {
assert_eq!(result, Ok(())); assert_eq!(result, Ok(()));
let result = result_receiver.try_recv().unwrap(); let result = result_receiver.try_recv().unwrap();
assert_eq!( assert_eq!(result, Ok(MatchStateInfo::artist_lookup(artist, lookup)));
result,
Ok(MbReturn::Match(EntityMatches::artist_lookup(
artist, lookup
)))
);
} }
fn lookup_release_group_expectation( fn lookup_release_group_expectation(
@ -667,9 +620,7 @@ mod tests {
let artist_id = album_artist_id(); let artist_id = album_artist_id();
assert_eq!( assert_eq!(
result, result,
Ok(MbReturn::Match(EntityMatches::album_lookup( Ok(MatchStateInfo::album_lookup(artist_id, album, lookup))
artist_id, album, lookup
)))
); );
} }
@ -710,12 +661,7 @@ mod tests {
assert_eq!(result, Ok(())); assert_eq!(result, Ok(()));
let result = result_receiver.try_recv().unwrap(); let result = result_receiver.try_recv().unwrap();
assert_eq!( assert_eq!(result, Ok(MatchStateInfo::artist_search(artist, matches)));
result,
Ok(MbReturn::Match(EntityMatches::artist_search(
artist, matches
)))
);
} }
fn search_release_group_expectation( fn search_release_group_expectation(
@ -770,21 +716,21 @@ mod tests {
let result = result_receiver.try_recv().unwrap(); let result = result_receiver.try_recv().unwrap();
assert_eq!( assert_eq!(
result, result,
Ok(MbReturn::Match(EntityMatches::album_search( Ok(MatchStateInfo::album_search(
artist_id.clone(), artist_id.clone(),
album_1, album_1,
matches_1 matches_1
))) ))
); );
let result = result_receiver.try_recv().unwrap(); let result = result_receiver.try_recv().unwrap();
assert_eq!( assert_eq!(
result, result,
Ok(MbReturn::Match(EntityMatches::album_search( Ok(MatchStateInfo::album_search(
artist_id.clone(), artist_id.clone(),
album_4, album_4,
matches_4 matches_4
))) ))
); );
} }

24
src/tui/lib/interface/musicbrainz/api/mod.rs
View File

@ -1,7 +1,5 @@
//! Module for accessing MusicBrainz metadata. //! Module for accessing MusicBrainz metadata.
use std::mem;
#[cfg(test)] #[cfg(test)]
use mockall::automock; use mockall::automock;
@ -49,26 +47,4 @@ pub struct Paged<T> {
pub next: NextPage, pub next: NextPage,
} }
// pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U, E> {
// match self {
// Ok(t) => Ok(op(t)),
// Err(e) => Err(e),
// }
// }
impl<T> Paged<T> {
pub fn map_paged_result<E, U, F: FnOnce(T) -> U>(
result: Result<Paged<T>, E>,
op: F,
next: &mut NextPage,
) -> Result<U, E> {
match result {
Ok(paged) => {
_ = mem::replace(next, paged.next);
Ok(op(paged.item))
}
Err(err) => Err(err),
}
}
}
pub type Error = musichoard::external::musicbrainz::api::Error; pub type Error = musichoard::external::musicbrainz::api::Error;

26
src/tui/lib/interface/musicbrainz/daemon/mod.rs
View File

@ -6,7 +6,7 @@ use musichoard::collection::{
musicbrainz::Mbid, musicbrainz::Mbid,
}; };
use crate::tui::{app::EntityMatches, lib::interface::musicbrainz::api::Error as MbApiError}; use crate::tui::{app::MatchStateInfo, lib::interface::musicbrainz::api::Error as MbApiError};
#[cfg(test)] #[cfg(test)]
use mockall::automock; use mockall::automock;
@ -26,20 +26,9 @@ impl fmt::Display for Error {
} }
} }
pub type MbApiResult = Result<MbReturn, MbApiError>; pub type MbApiResult = Result<MatchStateInfo, MbApiError>;
pub type ResultSender = mpsc::Sender<MbApiResult>; pub type ResultSender = mpsc::Sender<MbApiResult>;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MbReturn {
Match(EntityMatches),
Fetch(EntityList),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum EntityList {
Album(Vec<AlbumMeta>),
}
#[cfg_attr(test, automock)] #[cfg_attr(test, automock)]
pub trait IMbJobSender { pub trait IMbJobSender {
fn submit_foreground_job( fn submit_foreground_job(
@ -59,7 +48,6 @@ pub trait IMbJobSender {
pub enum MbParams { pub enum MbParams {
Lookup(LookupParams), Lookup(LookupParams),
Search(SearchParams), Search(SearchParams),
Browse(BrowseParams),
} }
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
@ -99,16 +87,6 @@ pub struct SearchReleaseGroupParams {
pub album: AlbumMeta, pub album: AlbumMeta,
} }
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BrowseParams {
ReleaseGroup(BrowseReleaseGroupParams),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BrowseReleaseGroupParams {
pub artist: Mbid,
}
impl MbParams { impl MbParams {
pub fn lookup_artist(artist: ArtistMeta, mbid: Mbid) -> Self { pub fn lookup_artist(artist: ArtistMeta, mbid: Mbid) -> Self {
MbParams::Lookup(LookupParams::Artist(LookupArtistParams { artist, mbid })) MbParams::Lookup(LookupParams::Artist(LookupArtistParams { artist, mbid }))

8
src/tui/ui/display.rs
View File

@ -5,7 +5,7 @@ use musichoard::collection::{
track::{TrackFormat, TrackQuality}, track::{TrackFormat, TrackQuality},
}; };
use crate::tui::app::{EntityMatches, MatchOption}; use crate::tui::app::{MatchOption, MatchStateInfo};
pub struct UiDisplay; pub struct UiDisplay;
@ -119,10 +119,10 @@ impl UiDisplay {
) )
} }
pub fn display_matching_info(info: &EntityMatches) -> String { pub fn display_matching_info(info: &MatchStateInfo) -> String {
match info { match info {
EntityMatches::Artist(m) => UiDisplay::display_artist_matching(&m.matching), MatchStateInfo::Artist(m) => UiDisplay::display_artist_matching(&m.matching),
EntityMatches::Album(m) => UiDisplay::display_album_matching(&m.matching), MatchStateInfo::Album(m) => UiDisplay::display_album_matching(&m.matching),
} }
} }

8
src/tui/ui/match_state.rs
View File

@ -2,7 +2,7 @@ use musichoard::collection::{album::AlbumMeta, artist::ArtistMeta};
use ratatui::widgets::{List, ListItem}; use ratatui::widgets::{List, ListItem};
use crate::tui::{ use crate::tui::{
app::{EntityMatches, MatchOption, WidgetState}, app::{MatchOption, MatchStateInfo, WidgetState},
ui::display::UiDisplay, ui::display::UiDisplay,
}; };
@ -13,10 +13,10 @@ pub struct MatchOverlay<'a, 'b> {
} }
impl<'a, 'b> MatchOverlay<'a, 'b> { impl<'a, 'b> MatchOverlay<'a, 'b> {
pub fn new(info: &'a EntityMatches, state: &'b mut WidgetState) -> Self { pub fn new(info: &'a MatchStateInfo, state: &'b mut WidgetState) -> Self {
match info { match info {
EntityMatches::Artist(m) => Self::artists(&m.matching, &m.list, state), MatchStateInfo::Artist(m) => Self::artists(&m.matching, &m.list, state),
EntityMatches::Album(m) => Self::albums(&m.matching, &m.list, state), MatchStateInfo::Album(m) => Self::albums(&m.matching, &m.list, state),
} }
} }

2
src/tui/ui/minibuffer.rs
View File

@ -65,7 +65,7 @@ impl Minibuffer<'_> {
}, },
AppState::Match(public) => Minibuffer { AppState::Match(public) => Minibuffer {
paragraphs: vec![ paragraphs: vec![
Paragraph::new(UiDisplay::display_matching_info(public.matches)), Paragraph::new(UiDisplay::display_matching_info(public.info)),
Paragraph::new("ctrl+g: abort"), Paragraph::new("ctrl+g: abort"),
], ],
columns: 2, columns: 2,

30
src/tui/ui/mod.rs
View File

@ -18,7 +18,7 @@ use musichoard::collection::{album::Album, Collection};
use crate::tui::{ use crate::tui::{
app::{ app::{
AppPublicState, AppState, Category, EntityMatches, IAppAccess, InputPublic, Selection, AppPublicState, AppState, Category, IAppAccess, InputPublic, MatchStateInfo, Selection,
WidgetState, WidgetState,
}, },
ui::{ ui::{
@ -140,7 +140,7 @@ impl Ui {
UiWidget::render_overlay_widget("Fetching", fetch_text, area, false, frame) UiWidget::render_overlay_widget("Fetching", fetch_text, area, false, frame)
} }
fn render_match_overlay(info: &EntityMatches, state: &mut WidgetState, frame: &mut Frame) { fn render_match_overlay(info: &MatchStateInfo, state: &mut WidgetState, frame: &mut Frame) {
let area = OverlayBuilder::default().build(frame.area()); let area = OverlayBuilder::default().build(frame.area());
let st = MatchOverlay::new(info, state); let st = MatchOverlay::new(info, state);
UiWidget::render_overlay_list_widget(&st.matching, st.list, st.state, true, area, frame) UiWidget::render_overlay_list_widget(&st.matching, st.list, st.state, true, area, frame)
@ -182,9 +182,7 @@ impl IUi for Ui {
AppState::Info(()) => Self::render_info_overlay(collection, selection, frame), AppState::Info(()) => Self::render_info_overlay(collection, selection, frame),
AppState::Reload(()) => Self::render_reload_overlay(frame), AppState::Reload(()) => Self::render_reload_overlay(frame),
AppState::Fetch(()) => Self::render_fetch_overlay(frame), AppState::Fetch(()) => Self::render_fetch_overlay(frame),
AppState::Match(public) => { AppState::Match(public) => Self::render_match_overlay(public.info, public.state, frame),
Self::render_match_overlay(public.matches, public.state, frame)
}
AppState::Error(msg) => Self::render_error_overlay("Error", msg, frame), AppState::Error(msg) => Self::render_error_overlay("Error", msg, frame),
AppState::Critical(msg) => Self::render_error_overlay("Critical Error", msg, frame), AppState::Critical(msg) => Self::render_error_overlay("Critical Error", msg, frame),
_ => {} _ => {}
@ -228,7 +226,7 @@ mod tests {
AppState::Search(s) => AppState::Search(s), AppState::Search(s) => AppState::Search(s),
AppState::Fetch(()) => AppState::Fetch(()), AppState::Fetch(()) => AppState::Fetch(()),
AppState::Match(ref mut m) => AppState::Match(MatchStatePublic { AppState::Match(ref mut m) => AppState::Match(MatchStatePublic {
matches: m.matches, info: m.info,
state: m.state, state: m.state,
}), }),
AppState::Error(s) => AppState::Error(s), AppState::Error(s) => AppState::Error(s),
@ -331,22 +329,22 @@ mod tests {
ArtistMeta::new(ArtistId::new("an artist")) ArtistMeta::new(ArtistId::new("an artist"))
} }
fn artist_matches() -> EntityMatches { fn artist_matches() -> MatchStateInfo {
let artist = artist_meta(); let artist = artist_meta();
let artist_match = Entity::with_score(artist.clone(), 80); let artist_match = Entity::with_score(artist.clone(), 80);
let list = vec![artist_match.clone(), artist_match.clone()]; let list = vec![artist_match.clone(), artist_match.clone()];
let mut info = EntityMatches::artist_search(artist, list); let mut info = MatchStateInfo::artist_search(artist, list);
info.push_cannot_have_mbid(); info.push_cannot_have_mbid();
info.push_manual_input_mbid(); info.push_manual_input_mbid();
info info
} }
fn artist_lookup() -> EntityMatches { fn artist_lookup() -> MatchStateInfo {
let artist = artist_meta(); let artist = artist_meta();
let artist_lookup = Entity::new(artist.clone()); let artist_lookup = Entity::new(artist.clone());
let mut info = EntityMatches::artist_lookup(artist, artist_lookup); let mut info = MatchStateInfo::artist_lookup(artist, artist_lookup);
info.push_cannot_have_mbid(); info.push_cannot_have_mbid();
info.push_manual_input_mbid(); info.push_manual_input_mbid();
info info
@ -368,24 +366,24 @@ mod tests {
) )
} }
fn album_matches() -> EntityMatches { fn album_matches() -> MatchStateInfo {
let artist_id = album_artist_id(); let artist_id = album_artist_id();
let album = album_meta(); let album = album_meta();
let album_match = Entity::with_score(album.clone(), 80); let album_match = Entity::with_score(album.clone(), 80);
let list = vec![album_match.clone(), album_match.clone()]; let list = vec![album_match.clone(), album_match.clone()];
let mut info = EntityMatches::album_search(artist_id, album, list); let mut info = MatchStateInfo::album_search(artist_id, album, list);
info.push_cannot_have_mbid(); info.push_cannot_have_mbid();
info.push_manual_input_mbid(); info.push_manual_input_mbid();
info info
} }
fn album_lookup() -> EntityMatches { fn album_lookup() -> MatchStateInfo {
let artist_id = album_artist_id(); let artist_id = album_artist_id();
let album = album_meta(); let album = album_meta();
let album_lookup = Entity::new(album.clone()); let album_lookup = Entity::new(album.clone());
let mut info = EntityMatches::album_lookup(artist_id, album, album_lookup); let mut info = MatchStateInfo::album_lookup(artist_id, album, album_lookup);
info.push_cannot_have_mbid(); info.push_cannot_have_mbid();
info.push_manual_input_mbid(); info.push_manual_input_mbid();
info info
@ -405,13 +403,13 @@ mod tests {
album_lookup(), album_lookup(),
]; ];
for matches in match_state_infos.iter() { for info in match_state_infos.iter() {
let mut widget_state = WidgetState::default().with_selected(Some(0)); let mut widget_state = WidgetState::default().with_selected(Some(0));
let mut app = AppPublic { let mut app = AppPublic {
inner: public_inner(collection, &mut selection), inner: public_inner(collection, &mut selection),
state: AppState::Match(MatchStatePublic { state: AppState::Match(MatchStatePublic {
matches, info,
state: &mut widget_state, state: &mut widget_state,
}), }),
input: None, input: None,