diff --git a/Cargo.toml b/Cargo.toml index 19b269e..4582b62 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -47,6 +47,11 @@ required-features = ["bin", "database-json", "library-beets", "library-beets-ssh name = "musichoard-edit" required-features = ["bin", "database-json"] +[[example]] +name = "musicbrainz-api---browse" +path = "examples/musicbrainz_api/browse.rs" +required-features = ["bin", "musicbrainz"] + [[example]] name = "musicbrainz-api---lookup" path = "examples/musicbrainz_api/lookup.rs" diff --git a/examples/musicbrainz_api/browse.rs b/examples/musicbrainz_api/browse.rs new file mode 100644 index 0000000..af8d968 --- /dev/null +++ b/examples/musicbrainz_api/browse.rs @@ -0,0 +1,98 @@ +use std::{thread, time}; + +use musichoard::{ + collection::musicbrainz::Mbid, + external::musicbrainz::{ + api::{browse::BrowseReleaseGroupRequest, MusicBrainzClient, NextPage, PageSettings}, + http::MusicBrainzHttp, + }, +}; +use structopt::StructOpt; +use uuid::Uuid; + +const USER_AGENT: &str = concat!( + "MusicHoard---examples---musicbrainz-api---browse/", + env!("CARGO_PKG_VERSION"), + " ( musichoard@thenineworlds.net )" +); + +#[derive(StructOpt)] +struct Opt { + #[structopt(subcommand)] + entity: OptEntity, +} + +#[derive(StructOpt)] +enum OptEntity { + #[structopt(about = "Browse release groups")] + ReleaseGroup(OptReleaseGroup), +} + +#[derive(StructOpt)] +enum OptReleaseGroup { + #[structopt(about = "Browse release groups of an artist")] + Artist(OptMbid), +} + +#[derive(StructOpt)] +struct OptMbid { + #[structopt(help = "MBID of the entity")] + mbid: Uuid, +} + +fn main() { + let opt = Opt::from_args(); + + println!("USER_AGENT: {USER_AGENT}"); + + let http = MusicBrainzHttp::new(USER_AGENT).expect("failed to create API client"); + let mut client = MusicBrainzClient::new(http); + + match opt.entity { + OptEntity::ReleaseGroup(opt_release_group) => match opt_release_group { + OptReleaseGroup::Artist(opt_mbid) => { + let mbid: Mbid = opt_mbid.mbid.into(); + let request = BrowseReleaseGroupRequest::artist(&mbid); + let mut paging = PageSettings::with_max_limit(); + + let mut response_counts: Vec = Vec::new(); + + loop { + let response = client + .browse_release_group(&request, &paging) + .expect("failed to make API call"); + + for rg in response.release_groups.iter() { + println!("{rg:?}\n"); + } + + let offset = response.page.release_group_offset; + let count = response.release_groups.len(); + response_counts.push(count); + let total = response.page.release_group_count; + + println!("Release group offset : {offset}"); + println!("Release groups in this response: {count}"); + println!("Release groups in total : {total}"); + + match response.page.next_page_offset(count) { + NextPage::Offset(next_offset) => paging.with_offset(next_offset), + NextPage::Complete => break, + } + + thread::sleep(time::Duration::from_secs(1)); + } + + println!( + "Total: {}={} release groups", + response_counts + .iter() + .map(|i| i.to_string()) + .collect::>() + .join("+"), + response_counts.iter().sum::(), + ); + } + }, + } +} diff --git a/examples/musicbrainz_api/lookup.rs b/examples/musicbrainz_api/lookup.rs index 29e02ee..139c2cf 100644 --- a/examples/musicbrainz_api/lookup.rs +++ b/examples/musicbrainz_api/lookup.rs @@ -1,5 +1,3 @@ -#![allow(non_snake_case)] - use musichoard::{ collection::musicbrainz::Mbid, external::musicbrainz::{ @@ -64,7 +62,7 @@ fn main() { } let response = client - .lookup_artist(request) + .lookup_artist(&request) .expect("failed to make API call"); println!("{response:#?}"); @@ -74,7 +72,7 @@ fn main() { let request = LookupReleaseGroupRequest::new(&mbid); let response = client - .lookup_release_group(request) + .lookup_release_group(&request) .expect("failed to make API call"); println!("{response:#?}"); diff --git a/examples/musicbrainz_api/search.rs b/examples/musicbrainz_api/search.rs index 96fd893..5d6f44f 100644 --- a/examples/musicbrainz_api/search.rs +++ b/examples/musicbrainz_api/search.rs @@ -1,5 +1,3 @@ -#![allow(non_snake_case)] - use std::{num::ParseIntError, str::FromStr}; use musichoard::{ @@ -7,7 +5,7 @@ use musichoard::{ external::musicbrainz::{ api::{ search::{SearchArtistRequest, SearchReleaseGroupRequest}, - MusicBrainzClient, + MusicBrainzClient, PageSettings, }, http::MusicBrainzHttp, }, @@ -108,8 +106,9 @@ fn main() { println!("Query: {query}"); + let paging = PageSettings::default(); let matches = client - .search_artist(query) + .search_artist(&query, &paging) .expect("failed to make API call"); println!("{matches:#?}"); @@ -140,8 +139,9 @@ fn main() { println!("Query: {query}"); + let paging = PageSettings::default(); let matches = client - .search_release_group(query) + .search_release_group(&query, &paging) .expect("failed to make API call"); println!("{matches:#?}"); diff --git a/src/external/musicbrainz/api/browse.rs b/src/external/musicbrainz/api/browse.rs new file mode 100644 index 0000000..9d1a21d --- /dev/null +++ b/src/external/musicbrainz/api/browse.rs @@ -0,0 +1,178 @@ +use std::fmt; + +use serde::Deserialize; + +use crate::{ + collection::musicbrainz::Mbid, + external::musicbrainz::{ + api::{ + ApiDisplay, Error, MbReleaseGroupMeta, MusicBrainzClient, NextPage, PageSettings, + SerdeMbReleaseGroupMeta, MB_BASE_URL, + }, + IMusicBrainzHttp, + }, +}; + +#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)] +#[serde(rename_all(deserialize = "kebab-case"))] +pub struct BrowseReleaseGroupPage { + pub release_group_offset: usize, + pub release_group_count: usize, +} + +impl BrowseReleaseGroupPage { + pub fn next_page_offset(&self, page_count: usize) -> NextPage { + NextPage::next_page_offset( + self.release_group_offset, + self.release_group_count, + page_count, + ) + } +} + +pub type SerdeBrowseReleaseGroupPage = BrowseReleaseGroupPage; + +impl MusicBrainzClient { + pub fn browse_release_group( + &mut self, + request: &BrowseReleaseGroupRequest, + paging: &PageSettings, + ) -> Result { + let entity = &request.entity; + let mbid = request.mbid.uuid().as_hyphenated(); + let page = ApiDisplay::format_page_settings(paging); + + let url = format!("{MB_BASE_URL}/release-group?{entity}={mbid}{page}"); + + let response: DeserializeBrowseReleaseGroupResponse = self.http.get(&url)?; + Ok(response.into()) + } +} + +pub struct BrowseReleaseGroupRequest<'a> { + entity: BrowseReleaseGroupRequestEntity, + mbid: &'a Mbid, +} + +enum BrowseReleaseGroupRequestEntity { + Artist, +} + +impl fmt::Display for BrowseReleaseGroupRequestEntity { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + BrowseReleaseGroupRequestEntity::Artist => write!(f, "artist"), + } + } +} + +impl<'a> BrowseReleaseGroupRequest<'a> { + pub fn artist(mbid: &'a Mbid) -> Self { + BrowseReleaseGroupRequest { + entity: BrowseReleaseGroupRequestEntity::Artist, + mbid, + } + } +} + +#[derive(Debug, PartialEq, Eq)] +pub struct BrowseReleaseGroupResponse { + pub release_groups: Vec, + pub page: BrowseReleaseGroupPage, +} + +#[derive(Clone, Deserialize)] +#[serde(rename_all(deserialize = "kebab-case"))] +struct DeserializeBrowseReleaseGroupResponse { + release_groups: Option>, + #[serde(flatten)] + page: SerdeBrowseReleaseGroupPage, +} + +impl From for BrowseReleaseGroupResponse { + fn from(value: DeserializeBrowseReleaseGroupResponse) -> Self { + BrowseReleaseGroupResponse { + page: value.page, + release_groups: value + .release_groups + .map(|rgs| rgs.into_iter().map(Into::into).collect()) + .unwrap_or_default(), + } + } +} + +#[cfg(test)] +mod tests { + use mockall::predicate; + + use crate::{ + collection::album::{AlbumPrimaryType, AlbumSecondaryType}, + external::musicbrainz::{ + api::{ + tests::next_page_test, SerdeAlbumDate, SerdeAlbumPrimaryType, + SerdeAlbumSecondaryType, SerdeMbid, MB_MAX_PAGE_LIMIT, + }, + MockIMusicBrainzHttp, + }, + }; + + use super::*; + + #[test] + fn browse_release_group_next_page() { + let page = BrowseReleaseGroupPage { + release_group_offset: 5, + release_group_count: 45, + }; + + next_page_test(|val| page.next_page_offset(val)); + } + + #[test] + fn browse_release_group() { + let mbid = "00000000-0000-0000-0000-000000000000"; + let mut http = MockIMusicBrainzHttp::new(); + + let de_release_group_offset = 24; + let de_release_group_count = 302; + let de_meta = SerdeMbReleaseGroupMeta { + id: SerdeMbid("11111111-1111-1111-1111-111111111111".try_into().unwrap()), + title: String::from("an album"), + first_release_date: SerdeAlbumDate((1986, 4).into()), + primary_type: Some(SerdeAlbumPrimaryType(AlbumPrimaryType::Album)), + secondary_types: Some(vec![SerdeAlbumSecondaryType( + AlbumSecondaryType::Compilation, + )]), + }; + let de_response = DeserializeBrowseReleaseGroupResponse { + page: SerdeBrowseReleaseGroupPage { + release_group_offset: de_release_group_offset, + release_group_count: de_release_group_count, + }, + release_groups: Some(vec![de_meta.clone()]), + }; + + let response = BrowseReleaseGroupResponse { + page: de_response.page, + release_groups: vec![de_meta.clone().into()], + }; + + let url = format!( + "https://musicbrainz.org/ws/2/release-group?artist={mbid}&limit={MB_MAX_PAGE_LIMIT}", + ); + let expect_response = de_response.clone(); + http.expect_get() + .times(1) + .with(predicate::eq(url)) + .return_once(|_| Ok(expect_response)); + + let mut client = MusicBrainzClient::new(http); + + let mbid: Mbid = mbid.try_into().unwrap(); + + let request = BrowseReleaseGroupRequest::artist(&mbid); + let paging = PageSettings::with_max_limit(); + let result = client.browse_release_group(&request, &paging).unwrap(); + assert_eq!(result, response); + } +} diff --git a/src/external/musicbrainz/api/lookup.rs b/src/external/musicbrainz/api/lookup.rs index 46be188..82197d5 100644 --- a/src/external/musicbrainz/api/lookup.rs +++ b/src/external/musicbrainz/api/lookup.rs @@ -14,7 +14,7 @@ use super::{MbArtistMeta, MbReleaseGroupMeta, SerdeMbArtistMeta, SerdeMbReleaseG impl MusicBrainzClient { pub fn lookup_artist( &mut self, - request: LookupArtistRequest, + request: &LookupArtistRequest, ) -> Result { let mut include: Vec = vec![]; @@ -35,7 +35,7 @@ impl MusicBrainzClient { pub fn lookup_release_group( &mut self, - request: LookupReleaseGroupRequest, + request: &LookupReleaseGroupRequest, ) -> Result { let url = format!( "{MB_BASE_URL}/release-group/{mbid}", @@ -152,7 +152,7 @@ mod tests { id: SerdeMbid("11111111-1111-1111-1111-111111111111".try_into().unwrap()), title: String::from("an album"), first_release_date: SerdeAlbumDate((1986, 4).into()), - primary_type: SerdeAlbumPrimaryType(AlbumPrimaryType::Album), + primary_type: Some(SerdeAlbumPrimaryType(AlbumPrimaryType::Album)), secondary_types: Some(vec![SerdeAlbumSecondaryType( AlbumSecondaryType::Compilation, )]), @@ -177,7 +177,7 @@ mod tests { let mbid: Mbid = "00000000-0000-0000-0000-000000000000".try_into().unwrap(); let mut request = LookupArtistRequest::new(&mbid); request.include_release_groups(); - let result = client.lookup_artist(request).unwrap(); + let result = client.lookup_artist(&request).unwrap(); assert_eq!(result, response); } @@ -192,7 +192,7 @@ mod tests { id: SerdeMbid("11111111-1111-1111-1111-111111111111".try_into().unwrap()), title: String::from("an album"), first_release_date: SerdeAlbumDate((1986, 4).into()), - primary_type: SerdeAlbumPrimaryType(AlbumPrimaryType::Album), + primary_type: Some(SerdeAlbumPrimaryType(AlbumPrimaryType::Album)), secondary_types: Some(vec![SerdeAlbumSecondaryType( AlbumSecondaryType::Compilation, )]), @@ -214,7 +214,7 @@ mod tests { let mbid: Mbid = "00000000-0000-0000-0000-000000000000".try_into().unwrap(); let request = LookupReleaseGroupRequest::new(&mbid); - let result = client.lookup_release_group(request).unwrap(); + let result = client.lookup_release_group(&request).unwrap(); assert_eq!(result, response); } diff --git a/src/external/musicbrainz/api/mod.rs b/src/external/musicbrainz/api/mod.rs index 70e9299..2f61f75 100644 --- a/src/external/musicbrainz/api/mod.rs +++ b/src/external/musicbrainz/api/mod.rs @@ -11,11 +11,14 @@ use crate::{ external::musicbrainz::HttpError, }; +pub mod browse; pub mod lookup; pub mod search; const MB_BASE_URL: &str = "https://musicbrainz.org/ws/2"; const MB_RATE_LIMIT_CODE: u16 = 503; +const MB_MAX_PAGE_LIMIT: usize = 100; + #[derive(Debug, PartialEq, Eq)] pub enum Error { /// The HTTP client failed. @@ -58,6 +61,46 @@ impl MusicBrainzClient { } } +#[derive(Default)] +pub struct PageSettings { + pub limit: Option, + pub offset: Option, +} + +impl PageSettings { + pub fn with_limit(limit: usize) -> Self { + PageSettings { + limit: Some(limit), + ..Default::default() + } + } + + pub fn with_max_limit() -> Self { + Self::with_limit(MB_MAX_PAGE_LIMIT) + } + + pub fn with_offset(&mut self, offset: usize) { + self.offset = Some(offset); + } +} + +#[derive(Debug, PartialEq, Eq)] +pub enum NextPage { + Offset(usize), + Complete, +} + +impl NextPage { + pub fn next_page_offset(offset: usize, total_count: usize, page_count: usize) -> NextPage { + let next_offset = offset + page_count; + if next_offset < total_count { + NextPage::Offset(next_offset) + } else { + NextPage::Complete + } + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct MbArtistMeta { pub id: Mbid, @@ -91,7 +134,7 @@ pub struct MbReleaseGroupMeta { pub id: Mbid, pub title: String, pub first_release_date: AlbumDate, - pub primary_type: AlbumPrimaryType, + pub primary_type: Option, pub secondary_types: Option>, } @@ -101,7 +144,7 @@ pub struct SerdeMbReleaseGroupMeta { id: SerdeMbid, title: String, first_release_date: SerdeAlbumDate, - primary_type: SerdeAlbumPrimaryType, + primary_type: Option, secondary_types: Option>, } @@ -111,7 +154,7 @@ impl From for MbReleaseGroupMeta { id: value.id.into(), title: value.title, first_release_date: value.first_release_date.into(), - primary_type: value.primary_type.into(), + primary_type: value.primary_type.map(Into::into), secondary_types: value .secondary_types .map(|v| v.into_iter().map(Into::into).collect()), @@ -122,6 +165,18 @@ impl From for MbReleaseGroupMeta { pub struct ApiDisplay; impl ApiDisplay { + fn format_page_settings(paging: &PageSettings) -> String { + let limit = paging + .limit + .map(|l| format!("&limit={l}")) + .unwrap_or_default(); + let offset = paging + .offset + .map(|o| format!("&offset={o}")) + .unwrap_or_default(); + format!("{limit}{offset}") + } + fn format_album_date(date: &AlbumDate) -> String { match date.year { Some(year) => match date.month { @@ -304,6 +359,45 @@ mod tests { assert!(!format!("{unk_err:?}").is_empty()); } + pub fn next_page_test(mut f: Fn) + where + Fn: FnMut(usize) -> NextPage, + { + let next = f(20); + assert_eq!(next, NextPage::Offset(25)); + + let next = f(40); + assert_eq!(next, NextPage::Complete); + + let next = f(100); + assert_eq!(next, NextPage::Complete); + } + + #[test] + fn next_page() { + next_page_test(|val| NextPage::next_page_offset(5, 45, val)); + } + + #[test] + fn format_page_settings() { + let paging = PageSettings::default(); + assert_eq!(ApiDisplay::format_page_settings(&paging), ""); + + let paging = PageSettings::with_max_limit(); + assert_eq!(ApiDisplay::format_page_settings(&paging), "&limit=100"); + + let mut paging = PageSettings::with_limit(45); + paging.with_offset(145); + assert_eq!( + ApiDisplay::format_page_settings(&paging), + "&limit=45&offset=145" + ); + + let mut paging = PageSettings::default(); + paging.with_offset(26); + assert_eq!(ApiDisplay::format_page_settings(&paging), "&offset=26"); + } + #[test] fn format_album_date() { assert_eq!( diff --git a/src/external/musicbrainz/api/search/artist.rs b/src/external/musicbrainz/api/search/artist.rs index 12d1bf1..8399c4b 100644 --- a/src/external/musicbrainz/api/search/artist.rs +++ b/src/external/musicbrainz/api/search/artist.rs @@ -3,7 +3,10 @@ use std::fmt; use serde::Deserialize; use crate::external::musicbrainz::api::{ - search::query::{impl_term, EmptyQuery, EmptyQueryJoin, Query, QueryJoin}, + search::{ + query::{impl_term, EmptyQuery, EmptyQueryJoin, Query, QueryJoin}, + SearchPage, SerdeSearchPage, + }, MbArtistMeta, SerdeMbArtistMeta, }; @@ -26,18 +29,22 @@ impl_term!(string, SearchArtist<'a>, String, &'a str); #[derive(Debug, PartialEq, Eq)] pub struct SearchArtistResponse { pub artists: Vec, + pub page: SearchPage, } #[derive(Clone, Deserialize)] #[serde(rename_all(deserialize = "kebab-case"))] pub struct DeserializeSearchArtistResponse { artists: Vec, + #[serde(flatten)] + page: SerdeSearchPage, } impl From for SearchArtistResponse { fn from(value: DeserializeSearchArtistResponse) -> Self { SearchArtistResponse { artists: value.artists.into_iter().map(Into::into).collect(), + page: value.page, } } } @@ -70,13 +77,15 @@ mod tests { use mockall::predicate; use crate::external::musicbrainz::{ - api::{MusicBrainzClient, SerdeMbid}, + api::{MusicBrainzClient, PageSettings, SerdeMbid}, MockIMusicBrainzHttp, }; use super::*; fn de_response() -> DeserializeSearchArtistResponse { + let de_offset = 24; + let de_count = 124; let de_artist = DeserializeSearchArtistResponseArtist { score: 67, meta: SerdeMbArtistMeta { @@ -88,6 +97,10 @@ mod tests { }; DeserializeSearchArtistResponse { artists: vec![de_artist.clone()], + page: SerdeSearchPage { + offset: de_offset, + count: de_count, + }, } } @@ -101,6 +114,7 @@ mod tests { meta: a.meta.into(), }) .collect(), + page: de_response.page, } } @@ -128,7 +142,8 @@ mod tests { let query = SearchArtistRequest::new().string(name); - let matches = client.search_artist(query).unwrap(); + let paging = PageSettings::default(); + let matches = client.search_artist(&query, &paging).unwrap(); assert_eq!(matches, response); } } diff --git a/src/external/musicbrainz/api/search/mod.rs b/src/external/musicbrainz/api/search/mod.rs index 564063b..6fcb4cc 100644 --- a/src/external/musicbrainz/api/search/mod.rs +++ b/src/external/musicbrainz/api/search/mod.rs @@ -9,6 +9,7 @@ pub use release_group::{ }; use paste::paste; +use serde::Deserialize; use url::form_urlencoded; use crate::external::musicbrainz::{ @@ -17,21 +18,40 @@ use crate::external::musicbrainz::{ artist::DeserializeSearchArtistResponse, release_group::DeserializeSearchReleaseGroupResponse, }, - Error, MusicBrainzClient, MB_BASE_URL, + ApiDisplay, Error, MusicBrainzClient, PageSettings, MB_BASE_URL, }, IMusicBrainzHttp, }; +use super::NextPage; + +#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)] +#[serde(rename_all(deserialize = "kebab-case"))] +pub struct SearchPage { + pub offset: usize, + pub count: usize, +} + +impl SearchPage { + pub fn next_page_offset(&self, page_count: usize) -> NextPage { + NextPage::next_page_offset(self.offset, self.count, page_count) + } +} + +pub type SerdeSearchPage = SearchPage; + macro_rules! impl_search_entity { ($name:ident, $entity:literal) => { paste! { pub fn []( &mut self, - query: [] + query: &[], + paging: &PageSettings, ) -> Result<[], Error> { let query: String = form_urlencoded::byte_serialize(format!("{query}").as_bytes()).collect(); - let url = format!("{MB_BASE_URL}/{entity}?query={query}", entity = $entity); + let page = ApiDisplay::format_page_settings(paging); + let url = format!("{MB_BASE_URL}/{entity}?query={query}{page}", entity = $entity); let response: [] = self.http.get(&url)?; Ok(response.into()) @@ -44,3 +64,20 @@ impl MusicBrainzClient { impl_search_entity!(Artist, "artist"); impl_search_entity!(ReleaseGroup, "release-group"); } + +#[cfg(test)] +mod tests { + use crate::external::musicbrainz::api::tests::next_page_test; + + use super::*; + + #[test] + fn search_next_page() { + let page = SearchPage { + offset: 5, + count: 45, + }; + + next_page_test(|val| page.next_page_offset(val)); + } +} diff --git a/src/external/musicbrainz/api/search/release_group.rs b/src/external/musicbrainz/api/search/release_group.rs index d33d558..ae36fe2 100644 --- a/src/external/musicbrainz/api/search/release_group.rs +++ b/src/external/musicbrainz/api/search/release_group.rs @@ -5,7 +5,10 @@ use serde::Deserialize; use crate::{ collection::{album::AlbumDate, musicbrainz::Mbid}, external::musicbrainz::api::{ - search::query::{impl_term, EmptyQuery, EmptyQueryJoin, Query, QueryJoin}, + search::{ + query::{impl_term, EmptyQuery, EmptyQueryJoin, Query, QueryJoin}, + SearchPage, SerdeSearchPage, + }, ApiDisplay, MbReleaseGroupMeta, SerdeMbReleaseGroupMeta, }, }; @@ -50,18 +53,22 @@ impl_term!(rgid, SearchReleaseGroup<'a>, Rgid, &'a Mbid); #[derive(Debug, PartialEq, Eq)] pub struct SearchReleaseGroupResponse { pub release_groups: Vec, + pub page: SearchPage, } #[derive(Clone, Deserialize)] #[serde(rename_all(deserialize = "kebab-case"))] pub struct DeserializeSearchReleaseGroupResponse { release_groups: Vec, + #[serde(flatten)] + page: SerdeSearchPage, } impl From for SearchReleaseGroupResponse { fn from(value: DeserializeSearchReleaseGroupResponse) -> Self { SearchReleaseGroupResponse { release_groups: value.release_groups.into_iter().map(Into::into).collect(), + page: value.page, } } } @@ -99,8 +106,8 @@ mod tests { collection::album::{AlbumPrimaryType, AlbumSecondaryType}, external::musicbrainz::{ api::{ - MusicBrainzClient, SerdeAlbumDate, SerdeAlbumPrimaryType, SerdeAlbumSecondaryType, - SerdeMbid, + MusicBrainzClient, PageSettings, SerdeAlbumDate, SerdeAlbumPrimaryType, + SerdeAlbumSecondaryType, SerdeMbid, }, MockIMusicBrainzHttp, }, @@ -109,18 +116,24 @@ mod tests { use super::*; fn de_response() -> DeserializeSearchReleaseGroupResponse { + let de_offset = 26; + let de_count = 126; let de_release_group = DeserializeSearchReleaseGroupResponseReleaseGroup { score: 67, meta: SerdeMbReleaseGroupMeta { id: SerdeMbid("11111111-1111-1111-1111-111111111111".try_into().unwrap()), title: String::from("an album"), first_release_date: SerdeAlbumDate((1986, 4).into()), - primary_type: SerdeAlbumPrimaryType(AlbumPrimaryType::Album), + primary_type: Some(SerdeAlbumPrimaryType(AlbumPrimaryType::Album)), secondary_types: Some(vec![SerdeAlbumSecondaryType(AlbumSecondaryType::Live)]), }, }; DeserializeSearchReleaseGroupResponse { release_groups: vec![de_release_group.clone()], + page: SerdeSearchPage { + offset: de_offset, + count: de_count, + }, } } @@ -134,6 +147,7 @@ mod tests { meta: rg.meta.into(), }) .collect(), + page: de_response.page, } } @@ -161,7 +175,8 @@ mod tests { let query = SearchReleaseGroupRequest::new().string(title); - let matches = client.search_release_group(query).unwrap(); + let paging = PageSettings::default(); + let matches = client.search_release_group(&query, &paging).unwrap(); assert_eq!(matches, response); } @@ -198,7 +213,8 @@ mod tests { .and() .first_release_date(&date); - let matches = client.search_release_group(query).unwrap(); + let paging = PageSettings::default(); + let matches = client.search_release_group(&query, &paging).unwrap(); assert_eq!(matches, response); } @@ -226,7 +242,8 @@ mod tests { let query = SearchReleaseGroupRequest::new().rgid(&rgid); - let matches = client.search_release_group(query).unwrap(); + let paging = PageSettings::default(); + let matches = client.search_release_group(&query, &paging).unwrap(); assert_eq!(matches, response); } } diff --git a/src/tui/app/machine/browse_state.rs b/src/tui/app/machine/browse_state.rs index a215740..00e9cca 100644 --- a/src/tui/app/machine/browse_state.rs +++ b/src/tui/app/machine/browse_state.rs @@ -1,7 +1,7 @@ use crate::tui::app::{ machine::{App, AppInner, AppMachine}, - selection::{Delta, ListSelection}, - AppPublicState, AppState, IAppInteractBrowse, + selection::ListSelection, + AppPublicState, AppState, Delta, IAppInteractBrowse, }; pub struct BrowseState; diff --git a/src/tui/app/machine/match_state.rs b/src/tui/app/machine/match_state.rs index de68e30..19e0b3c 100644 --- a/src/tui/app/machine/match_state.rs +++ b/src/tui/app/machine/match_state.rs @@ -9,8 +9,8 @@ use musichoard::collection::{ use crate::tui::{ app::{ machine::{fetch_state::FetchState, input::Input, App, AppInner, AppMachine}, - AlbumMatches, AppPublicState, AppState, ArtistMatches, IAppInteractMatch, ListOption, - MatchOption, MatchStateInfo, MatchStatePublic, WidgetState, + AlbumMatches, AppPublicState, AppState, ArtistMatches, Delta, IAppInteractMatch, + ListOption, MatchOption, MatchStateInfo, MatchStatePublic, WidgetState, }, lib::interface::musicbrainz::api::{Lookup, Match}, }; @@ -243,19 +243,19 @@ impl<'a> From<&'a mut MatchState> for AppPublicState<'a> { impl IAppInteractMatch for AppMachine { type APP = App; - fn prev_match(mut self) -> Self::APP { + fn decrement_match(mut self, delta: Delta) -> Self::APP { if let Some(index) = self.state.state.list.selected() { - let result = index.saturating_sub(1); + let result = index.saturating_sub(delta.as_usize(&self.state.state)); self.state.state.list.select(Some(result)); } self.into() } - fn next_match(mut self) -> Self::APP { + fn increment_match(mut self, delta: Delta) -> Self::APP { let index = self.state.state.list.selected().unwrap(); let to = cmp::min( - index.saturating_add(1), + index.saturating_add(delta.as_usize(&self.state.state)), self.state.current.len().saturating_sub(1), ); self.state.state.list.select(Some(to)); @@ -473,38 +473,38 @@ mod tests { assert_eq!(matches.state.current, matches_info); assert_eq!(matches.state.state, widget_state); - let matches = matches.prev_match().unwrap_match(); + let matches = matches.decrement_match(Delta::Line).unwrap_match(); assert_eq!(matches.state.current, matches_info); assert_eq!(matches.state.state.list.selected(), Some(0)); let mut matches = matches; for ii in 1..len { - matches = matches.next_match().unwrap_match(); + matches = matches.increment_match(Delta::Line).unwrap_match(); assert_eq!(matches.state.current, matches_info); assert_eq!(matches.state.state.list.selected(), Some(ii)); } // Next is CannotHaveMBID - let matches = matches.next_match().unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); assert_eq!(matches.state.current, matches_info); assert_eq!(matches.state.state.list.selected(), Some(len)); // Next is ManualInputMbid - let matches = matches.next_match().unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); assert_eq!(matches.state.current, matches_info); assert_eq!(matches.state.state.list.selected(), Some(len + 1)); - let matches = matches.next_match().unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); assert_eq!(matches.state.current, matches_info); assert_eq!(matches.state.state.list.selected(), Some(len + 1)); // Go prev_match first as selecting on manual input does not go back to fetch. - let matches = matches.prev_match().unwrap_match(); + let matches = matches.decrement_match(Delta::Line).unwrap_match(); matches.select().unwrap_fetch(); } @@ -619,10 +619,10 @@ mod tests { AppMachine::match_state(inner(music_hoard(vec![])), match_state(album_match())); // album_match has two matches which means that the fourth option should be manual input. - let matches = matches.next_match().unwrap_match(); - let matches = matches.next_match().unwrap_match(); - let matches = matches.next_match().unwrap_match(); - let matches = matches.next_match().unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); let app = matches.select(); @@ -657,8 +657,8 @@ mod tests { ); // There are no matches which means that the second option should be manual input. - let matches = matches.next_match().unwrap_match(); - let matches = matches.next_match().unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); let mut app = matches.select(); app = input_mbid(app); @@ -691,8 +691,8 @@ mod tests { ); // There are no matches which means that the second option should be manual input. - let matches = matches.next_match().unwrap_match(); - let matches = matches.next_match().unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); + let matches = matches.increment_match(Delta::Line).unwrap_match(); let mut app = matches.select(); app = input_mbid(app); diff --git a/src/tui/app/mod.rs b/src/tui/app/mod.rs index a44cc28..e7bd921 100644 --- a/src/tui/app/mod.rs +++ b/src/tui/app/mod.rs @@ -2,7 +2,8 @@ mod machine; mod selection; pub use machine::App; -pub use selection::{Category, Delta, Selection, WidgetState}; +use ratatui::widgets::ListState; +pub use selection::{Category, Selection}; use musichoard::collection::{ album::AlbumMeta, @@ -124,8 +125,8 @@ pub trait IAppEventFetch { pub trait IAppInteractMatch { type APP: IApp; - fn prev_match(self) -> Self::APP; - fn next_match(self) -> Self::APP; + fn decrement_match(self, delta: Delta) -> Self::APP; + fn increment_match(self, delta: Delta) -> Self::APP; fn select(self) -> Self::APP; fn abort(self) -> Self::APP; @@ -159,6 +160,40 @@ pub trait IAppInteractError { fn dismiss_error(self) -> Self::APP; } +#[derive(Clone, Debug, Default)] +pub struct WidgetState { + pub list: ListState, + pub height: usize, +} + +impl PartialEq for WidgetState { + fn eq(&self, other: &Self) -> bool { + self.list.selected().eq(&other.list.selected()) && self.height.eq(&other.height) + } +} + +impl WidgetState { + #[must_use] + pub const fn with_selected(mut self, selected: Option) -> Self { + self.list = self.list.with_selected(selected); + self + } +} + +pub enum Delta { + Line, + Page, +} + +impl Delta { + fn as_usize(&self, state: &WidgetState) -> usize { + match self { + Delta::Line => 1, + Delta::Page => state.height.saturating_sub(1), + } + } +} + // It would be preferable to have a getter for each field separately. However, the selection field // needs to be mutably accessible requiring a mutable borrow of the entire struct if behind a trait. // This in turn complicates simultaneous field access since only a single mutable borrow is allowed. diff --git a/src/tui/app/selection/album.rs b/src/tui/app/selection/album.rs index 2f89967..d4e8f8d 100644 --- a/src/tui/app/selection/album.rs +++ b/src/tui/app/selection/album.rs @@ -5,9 +5,12 @@ use musichoard::collection::{ track::Track, }; -use crate::tui::app::selection::{ - track::{KeySelectTrack, TrackSelection}, - Delta, SelectionState, WidgetState, +use crate::tui::app::{ + selection::{ + track::{KeySelectTrack, TrackSelection}, + SelectionState, + }, + Delta, WidgetState, }; #[derive(Clone, Debug, PartialEq)] diff --git a/src/tui/app/selection/artist.rs b/src/tui/app/selection/artist.rs index 045455a..851bd52 100644 --- a/src/tui/app/selection/artist.rs +++ b/src/tui/app/selection/artist.rs @@ -6,9 +6,12 @@ use musichoard::collection::{ track::Track, }; -use crate::tui::app::selection::{ - album::{AlbumSelection, KeySelectAlbum}, - Delta, SelectionState, WidgetState, +use crate::tui::app::{ + selection::{ + album::{AlbumSelection, KeySelectAlbum}, + SelectionState, + }, + Delta, WidgetState, }; #[derive(Clone, Debug, PartialEq)] diff --git a/src/tui/app/selection/mod.rs b/src/tui/app/selection/mod.rs index da31713..947db24 100644 --- a/src/tui/app/selection/mod.rs +++ b/src/tui/app/selection/mod.rs @@ -5,7 +5,10 @@ mod track; use musichoard::collection::{album::Album, artist::Artist, track::Track, Collection}; use ratatui::widgets::ListState; -use artist::{ArtistSelection, KeySelectArtist}; +use crate::tui::app::{ + selection::artist::{ArtistSelection, KeySelectArtist}, + Delta, WidgetState, +}; #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Category { @@ -24,40 +27,6 @@ pub struct SelectionState<'a, T> { pub index: usize, } -#[derive(Clone, Debug, Default)] -pub struct WidgetState { - pub list: ListState, - pub height: usize, -} - -impl PartialEq for WidgetState { - fn eq(&self, other: &Self) -> bool { - self.list.selected().eq(&other.list.selected()) && self.height.eq(&other.height) - } -} - -impl WidgetState { - #[must_use] - pub const fn with_selected(mut self, selected: Option) -> Self { - self.list = self.list.with_selected(selected); - self - } -} - -pub enum Delta { - Line, - Page, -} - -impl Delta { - fn as_usize(&self, state: &WidgetState) -> usize { - match self { - Delta::Line => 1, - Delta::Page => state.height.saturating_sub(1), - } - } -} - impl Selection { pub fn new(artists: &[Artist]) -> Self { Selection { diff --git a/src/tui/app/selection/track.rs b/src/tui/app/selection/track.rs index adec55b..1fa18d5 100644 --- a/src/tui/app/selection/track.rs +++ b/src/tui/app/selection/track.rs @@ -2,7 +2,7 @@ use std::cmp; use musichoard::collection::track::{Track, TrackId, TrackNum}; -use crate::tui::app::selection::{Delta, SelectionState, WidgetState}; +use crate::tui::app::{selection::SelectionState, Delta, WidgetState}; #[derive(Clone, Debug, PartialEq)] pub struct TrackSelection { diff --git a/src/tui/handler.rs b/src/tui/handler.rs index cf04371..f046da3 100644 --- a/src/tui/handler.rs +++ b/src/tui/handler.rs @@ -212,8 +212,10 @@ impl IEventHandlerPrivate for EventHandler { // Abort. KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => app.abort(), // Select. - KeyCode::Up => app.prev_match(), - KeyCode::Down => app.next_match(), + KeyCode::Up => app.decrement_match(Delta::Line), + KeyCode::Down => app.increment_match(Delta::Line), + KeyCode::PageUp => app.decrement_match(Delta::Page), + KeyCode::PageDown => app.increment_match(Delta::Page), KeyCode::Enter => app.select(), // Othey keys. _ => app.no_op(), diff --git a/src/tui/lib/external/musicbrainz/api/mod.rs b/src/tui/lib/external/musicbrainz/api/mod.rs index f248f1d..35156c5 100644 --- a/src/tui/lib/external/musicbrainz/api/mod.rs +++ b/src/tui/lib/external/musicbrainz/api/mod.rs @@ -18,7 +18,7 @@ use musichoard::{ SearchArtistRequest, SearchArtistResponseArtist, SearchReleaseGroupRequest, SearchReleaseGroupResponseReleaseGroup, }, - MusicBrainzClient, + MusicBrainzClient, PageSettings, }, IMusicBrainzHttp, }, @@ -41,7 +41,7 @@ impl IMusicBrainz for MusicBrainz { fn lookup_artist(&mut self, mbid: &Mbid) -> Result, Error> { let request = LookupArtistRequest::new(mbid); - let mb_response = self.client.lookup_artist(request)?; + let mb_response = self.client.lookup_artist(&request)?; Ok(from_lookup_artist_response(mb_response)) } @@ -49,7 +49,7 @@ impl IMusicBrainz for MusicBrainz { fn lookup_release_group(&mut self, mbid: &Mbid) -> Result, Error> { let request = LookupReleaseGroupRequest::new(mbid); - let mb_response = self.client.lookup_release_group(request)?; + let mb_response = self.client.lookup_release_group(&request)?; Ok(from_lookup_release_group_response(mb_response)) } @@ -57,7 +57,8 @@ impl IMusicBrainz for MusicBrainz { fn search_artist(&mut self, artist: &ArtistMeta) -> Result>, Error> { let query = SearchArtistRequest::new().string(&artist.id.name); - let mb_response = self.client.search_artist(query)?; + let paging = PageSettings::default(); + let mb_response = self.client.search_artist(&query, &paging)?; Ok(mb_response .artists @@ -82,7 +83,8 @@ impl IMusicBrainz for MusicBrainz { .and() .release_group(&album.id.title); - let mb_response = self.client.search_release_group(query)?; + let paging = PageSettings::default(); + let mb_response = self.client.search_release_group(&query, &paging)?; Ok(mb_response .release_groups @@ -115,7 +117,7 @@ fn from_lookup_release_group_response(entity: LookupReleaseGroupResponse) -> Loo seq: AlbumSeq::default(), info: AlbumInfo { musicbrainz: MbRefOption::Some(entity.meta.id.into()), - primary_type: Some(entity.meta.primary_type), + primary_type: entity.meta.primary_type, secondary_types: entity.meta.secondary_types.unwrap_or_default(), }, }, @@ -150,7 +152,7 @@ fn from_search_release_group_response_release_group( seq: AlbumSeq::default(), info: AlbumInfo { musicbrainz: MbRefOption::Some(entity.meta.id.into()), - primary_type: Some(entity.meta.primary_type), + primary_type: entity.meta.primary_type, secondary_types: entity.meta.secondary_types.unwrap_or_default(), }, },