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

WIP: use unique artist id

Browse Source
This commit is contained in:
Wojciech Kozlowski 2025-01-19 10:22:48 +01:00
parent 3901c161bd
commit 3b0fa28dfc
33 changed files with 874 additions and 604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.gitea/workflows/gitea-ci.yaml
View File

@ -22,11 +22,11 @@ jobs:
steps:
- uses: actions/checkout@v3
- run: cargo build --no-default-features --all-targets
- run: cargo test --no-default-features --all-targets --no-fail-fast
- run: cargo test --no-default-features --all-targets --no-fail-fast -- --include-ignored
- run: cargo build --all-targets
- run: cargo test --all-targets --no-fail-fast
- run: cargo test --all-targets --no-fail-fast -- --include-ignored
- run: cargo build --all-features --all-targets
- run: cargo test --all-features --all-targets --no-fail-fast
- run: cargo test --all-features --all-targets --no-fail-fast -- --include-ignored
- run: >-
grcov target/debug/profraw
--binary-path target/debug/

19
src/core/collection/album.rs
View File

@ -1,7 +1,7 @@
use std::mem;
use crate::core::collection::{
merge::{Merge, MergeSorted},
merge::{IntoId, Merge, MergeSorted, WithId},
musicbrainz::{MbAlbumRef, MbRefOption},
track::{Track, TrackFormat},
};
@ -208,6 +208,23 @@ impl Ord for Album {
}
}
impl WithId for Album {
type Id = AlbumId;
fn id(&self) -> &Self::Id {
&self.meta.id
}
}
impl IntoId for Album {
type Id = AlbumId;
type IdSelf = Album;
fn into_id(self, _: &Self::Id) -> Self::IdSelf {
self
}
}
impl Merge for Album {
fn merge_in_place(&mut self, other: Self) {
self.meta.merge_in_place(other.meta);

248
src/core/collection/artist.rs
View File

@ -11,56 +11,57 @@ use crate::core::collection::{
string::{self, NormalString},
};
use super::merge::WithId;
/// An artist.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Artist {
pub id: ArtistId,
pub meta: ArtistMeta,
pub albums: Vec<Album>,
}
/// Artist metadata.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ArtistMeta {
pub id: ArtistId,
pub name: ArtistName,
pub sort: Option<ArtistName>,
pub info: ArtistInfo,
}
/// Artist non-identifier metadata.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ArtistInfo {
pub sort: Option<String>,
pub mb_ref: ArtistMbRef,
pub properties: HashMap<String, Vec<String>>,
}
/// The artist identifier.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ArtistId {
pub name: String,
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ArtistId(pub usize);
impl From<usize> for ArtistId {
fn from(value: usize) -> Self {
ArtistId(value)
}
}
impl AsRef<ArtistId> for ArtistId {
fn as_ref(&self) -> &ArtistId {
self
}
}
impl Display for ArtistId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.0)
}
}
/// The artist name.
pub type ArtistName = String;
/// Unique database identifier. Use MBID for this purpose.
pub type ArtistMbRef = MbRefOption<MbArtistRef>;
impl PartialOrd for Artist {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Artist {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
self.meta.cmp(&other.meta)
}
}
impl Merge for Artist {
fn merge_in_place(&mut self, other: Self) {
self.meta.merge_in_place(other.meta);
self.albums = MergeAlbums::merge_albums(mem::take(&mut self.albums), other.albums);
}
}
#[derive(Debug, Default)]
struct MergeAlbums {
primary_by_lib_id: HashMap<u32, Album>,
@ -74,10 +75,10 @@ impl MergeAlbums {
fn merge_albums(primary_albums: Vec<Album>, secondary_albums: Vec<Album>) -> Vec<Album> {
let mut cache = MergeAlbums::new(primary_albums);
cache.merge_albums_by_lib_id(secondary_albums);
cache.merged.extend(MergeCollections::merge_by_name(
cache.primary_by_title,
cache.secondary_by_title,
));
let (merged, left) =
MergeCollections::merge_by_name(cache.primary_by_title, cache.secondary_by_title);
cache.merged.extend(merged);
cache.merged.extend(left);
cache.merged.sort_unstable();
cache.merged
}
@ -140,55 +141,65 @@ impl MergeAlbums {
impl Artist {
/// Create new [`Artist`] with the given [`ArtistId`].
pub fn new<Id: Into<ArtistId>>(id: Id) -> Self {
pub fn new<Id: Into<ArtistId>, Name: Into<ArtistName>>(id: Id, name: Name) -> Self {
Artist {
meta: ArtistMeta::new(id),
id: id.into(),
meta: ArtistMeta::new(name),
albums: vec![],
}
}
}
impl ArtistMeta {
pub fn new<Id: Into<ArtistId>>(id: Id) -> Self {
pub fn new<Name: Into<ArtistName>>(name: Name) -> Self {
ArtistMeta {
id: id.into(),
name: name.into(),
sort: None,
info: ArtistInfo::default(),
}
}
// TODO: move to info once name moves there too.
pub fn compatible(&self, other: &ArtistMeta) -> bool {
let names_compatible =
string::normalize_string(&self.id.name) == string::normalize_string(&other.id.name);
string::normalize_string(&self.name) == string::normalize_string(&other.name);
let mb_ref_compatible = self.info.mb_ref.is_none()
|| other.info.mb_ref.is_none()
|| (self.info.mb_ref == other.info.mb_ref);
names_compatible && mb_ref_compatible
}
pub fn get_sort_key(&self) -> (&str,) {
(self.sort.as_ref().unwrap_or(&self.name),)
}
pub fn with_sort<S: Into<String>>(mut self, name: S) -> Self {
self.sort = Some(name.into());
self
}
pub fn with_mb_ref(mut self, mb_ref: ArtistMbRef) -> Self {
self.info.set_mb_ref(mb_ref);
self
}
pub fn set_mb_ref(&mut self, mb_ref: ArtistMbRef) {
self.info.set_mb_ref(mb_ref);
}
pub fn clear_mb_ref(&mut self) {
self.info.clear_mb_ref();
}
pub fn get_sort_key(&self) -> (&str,) {
(self.info.sort.as_ref().unwrap_or(&self.id.name),)
}
}
impl ArtistInfo {
pub fn with_mb_ref(mut self, mb_ref: ArtistMbRef) -> Self {
self.set_mb_ref(mb_ref);
self
}
pub fn set_mb_ref(&mut self, mb_ref: ArtistMbRef) {
self.mb_ref = mb_ref;
}
pub fn clear_mb_ref(&mut self) {
self.mb_ref.take();
}
// In the functions below, it would be better to use `contains` instead of `iter().any`, but for
// type reasons that does not work:
// https://stackoverflow.com/questions/48985924/why-does-a-str-not-coerce-to-a-string-when-using-veccontains
pub fn add_to_property<S: AsRef<str> + Into<String>>(&mut self, property: S, values: Vec<S>) {
match self.properties.get_mut(property.as_ref()) {
Some(container) => {
@ -209,19 +220,6 @@ impl ArtistInfo {
}
}
pub fn with_mb_ref(mut self, mb_ref: ArtistMbRef) -> Self {
self.set_mb_ref(mb_ref);
self
}
pub fn set_mb_ref(&mut self, mb_ref: ArtistMbRef) {
self.mb_ref = mb_ref;
}
pub fn clear_mb_ref(&mut self) {
self.mb_ref.take();
}
pub fn remove_from_property<S: AsRef<str>>(&mut self, property: S, values: Vec<S>) {
if let Some(container) = self.properties.get_mut(property.as_ref()) {
container.retain(|val| !values.iter().any(|x| x.as_ref() == val));
@ -243,6 +241,49 @@ impl ArtistInfo {
}
}
impl WithId for Artist {
type Id = ArtistId;
fn id(&self) -> &Self::Id {
&self.id
}
}
impl Merge for Artist {
fn merge_in_place(&mut self, other: Self) {
assert_eq!(self.id, other.id);
self.meta.merge_in_place(other.meta);
self.albums = MergeAlbums::merge_albums(mem::take(&mut self.albums), other.albums);
}
}
impl Merge for ArtistMeta {
fn merge_in_place(&mut self, other: Self) {
assert!(self.compatible(&other));
// No merge for name - always keep original.
self.info.merge_in_place(other.info);
}
}
impl Merge for ArtistInfo {
fn merge_in_place(&mut self, other: Self) {
self.mb_ref = self.mb_ref.take().or(other.mb_ref);
self.properties.merge_in_place(other.properties);
}
}
impl PartialOrd for Artist {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Artist {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
self.meta.cmp(&other.meta)
}
}
impl PartialOrd for ArtistMeta {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
@ -255,45 +296,6 @@ impl Ord for ArtistMeta {
}
}
impl Merge for ArtistMeta {
fn merge_in_place(&mut self, other: Self) {
assert!(self.compatible(&other));
self.info.merge_in_place(other.info);
}
}
impl Merge for ArtistInfo {
fn merge_in_place(&mut self, other: Self) {
self.sort = self.sort.take().or(other.sort);
self.mb_ref = self.mb_ref.take().or(other.mb_ref);
self.properties.merge_in_place(other.properties);
}
}
impl<S: Into<String>> From<S> for ArtistId {
fn from(value: S) -> Self {
ArtistId::new(value)
}
}
impl AsRef<ArtistId> for ArtistId {
fn as_ref(&self) -> &ArtistId {
self
}
}
impl ArtistId {
pub fn new<S: Into<String>>(name: S) -> ArtistId {
ArtistId { name: name.into() }
}
}
impl Display for ArtistId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.name)
}
}
#[cfg(test)]
mod tests {
use crate::{
@ -315,40 +317,39 @@ mod tests {
#[test]
fn set_clear_musicbrainz_url() {
let mut artist = Artist::new(ArtistId::new("an artist"));
let mut info = ArtistInfo::default();
let mut expected: MbRefOption<MbArtistRef> = MbRefOption::None;
assert_eq!(artist.meta.info.mb_ref, expected);
assert_eq!(info.mb_ref, expected);
// Setting a URL on an artist.
artist.meta.info.set_mb_ref(MbRefOption::Some(
// Setting a URL on an info.
info.set_mb_ref(MbRefOption::Some(
MbArtistRef::from_url_str(MUSICBRAINZ).unwrap(),
));
expected.replace(MbArtistRef::from_url_str(MUSICBRAINZ).unwrap());
assert_eq!(artist.meta.info.mb_ref, expected);
assert_eq!(info.mb_ref, expected);
artist.meta.info.set_mb_ref(MbRefOption::Some(
info.set_mb_ref(MbRefOption::Some(
MbArtistRef::from_url_str(MUSICBRAINZ).unwrap(),
));
assert_eq!(artist.meta.info.mb_ref, expected);
assert_eq!(info.mb_ref, expected);
artist.meta.info.set_mb_ref(MbRefOption::Some(
info.set_mb_ref(MbRefOption::Some(
MbArtistRef::from_url_str(MUSICBRAINZ_2).unwrap(),
));
expected.replace(MbArtistRef::from_url_str(MUSICBRAINZ_2).unwrap());
assert_eq!(artist.meta.info.mb_ref, expected);
assert_eq!(info.mb_ref, expected);
// Clearing URLs.
artist.meta.info.clear_mb_ref();
info.clear_mb_ref();
expected.take();
assert_eq!(artist.meta.info.mb_ref, expected);
assert_eq!(info.mb_ref, expected);
}
#[test]
fn add_to_remove_from_property() {
let mut artist = Artist::new(ArtistId::new("an artist"));
let mut info = ArtistInfo::default();
let info = &mut artist.meta.info;
let mut expected: Vec<String> = vec![];
assert!(info.properties.is_empty());
@ -418,9 +419,8 @@ mod tests {
#[test]
fn set_clear_musicbutler_urls() {
let mut artist = Artist::new(ArtistId::new("an artist"));
let mut info = ArtistInfo::default();
let info = &mut artist.meta.info;
let mut expected: Vec<String> = vec![];
assert!(info.properties.is_empty());
@ -456,7 +456,8 @@ mod tests {
fn merge_artist_no_overlap() {
let left = FULL_COLLECTION[0].to_owned();
let mut right = FULL_COLLECTION[1].to_owned();
right.meta.id = left.meta.id.clone();
right.id = left.id;
right.meta.name = left.meta.name.clone();
right.meta.info.mb_ref = MbRefOption::None;
right.meta.info.properties = HashMap::new();
@ -493,7 +494,8 @@ mod tests {
fn merge_artist_overlap() {
let mut left = FULL_COLLECTION[0].to_owned();
let mut right = FULL_COLLECTION[1].to_owned();
right.meta.id = left.meta.id.clone();
right.id = left.id;
right.meta.name = left.meta.name.clone();
right.meta.info.mb_ref = left.meta.info.mb_ref.clone();
// The right collection needs more albums than we modify to make sure some do not overlap.
@ -530,7 +532,7 @@ mod tests {
#[test]
#[should_panic(expected = "multiple secondaries unsupported")]
fn merge_two_db_albums_to_one_lib_album() {
let mut left = Artist::new(ArtistId::new("Artist"));
let mut left = Artist::new(0, "Artist");
let mut right = left.clone();
let album = Album::new(AlbumId::new("Album"));
@ -547,7 +549,7 @@ mod tests {
#[test]
#[should_panic(expected = "multiple primaries unsupported")]
fn merge_one_db_album_to_two_lib_albums() {
let mut left = Artist::new(ArtistId::new("Artist"));
let mut left = Artist::new(0, "Artist");
let mut right = left.clone();
let album = Album::new(AlbumId::new("Album"));
@ -564,7 +566,7 @@ mod tests {
#[test]
fn merge_normalized_album_titles() {
let mut left = Artist::new(ArtistId::new("Artist"));
let mut left = Artist::new(0, "Artist");
let mut right = left.clone();
left.albums
@ -589,7 +591,7 @@ mod tests {
#[test]
fn merge_multiple_singletons() {
let mut left = Artist::new(ArtistId::new("Artist"));
let mut left = Artist::new(0, "Artist");
let mut right = left.clone();
left.albums.push(Album::new(AlbumId::new("Singleton 1")));
@ -615,7 +617,7 @@ mod tests {
#[test]
fn merge_two_db_albums_to_one_lib_album_with_ids() {
let mut left = Artist::new(ArtistId::new("Artist"));
let mut left = Artist::new(0, "Artist");
let mut right = left.clone();
let album = Album::new(AlbumId::new("Album"));

29
src/core/collection/merge.rs
View File

@ -105,10 +105,26 @@ impl<T> NormalMap<T> {
}
}
pub trait WithId {
type Id;
fn id(&self) -> &Self::Id;
}
pub trait IntoId {
type Id;
type IdSelf;
fn into_id(self, id: &Self::Id) -> Self::IdSelf;
}
pub struct MergeCollections;
impl MergeCollections {
pub fn merge_by_name<T: Merge>(mut primary: NormalMap<T>, secondary: NormalMap<T>) -> Vec<T> {
pub fn merge_by_name<Id, T1: Merge + WithId<Id = Id>, T2: IntoId<Id = Id, IdSelf = T1>>(
mut primary: NormalMap<T2>,
secondary: NormalMap<T1>,
) -> (Vec<T1>, Vec<T2>) {
let mut merged = vec![];
for (title, mut secondary_items) in secondary.0.into_iter() {
match primary.remove(&title) {
@ -117,14 +133,17 @@ impl MergeCollections {
// added once encountered in the wild.
assert_eq!(primary_items.len(), 1, "multiple primaries unsupported");
assert_eq!(secondary_items.len(), 1, "multiple secondaries unsupported");
let mut primary_item = primary_items.pop().unwrap();
primary_item.merge_in_place(secondary_items.pop().unwrap());
let secondary_item = secondary_items.pop().unwrap();
let id = secondary_item.id();
let mut primary_item = primary_items.pop().unwrap().into_id(id);
primary_item.merge_in_place(secondary_item);
merged.push(primary_item);
}
None => merged.extend(secondary_items),
}
}
merged.extend(primary.0.into_values().flatten());
merged
(merged, primary.0.into_values().flatten().collect())
}
}

9
src/core/interface/database/mod.rs
View File

@ -5,7 +5,7 @@ use std::fmt;
#[cfg(test)]
use mockall::automock;
use crate::core::collection::{self, Collection};
use crate::{collection::artist::{ArtistId, ArtistMeta}, core::collection::{self, Collection}};
/// Trait for interacting with the database.
#[cfg_attr(test, automock)]
@ -18,6 +18,9 @@ pub trait IDatabase {
/// Save collection to the database.
fn save(&mut self, collection: &Collection) -> Result<(), SaveError>;
/// Insert an artist into the database and return its assigned ID.
fn insert_artist(&mut self, artist: &ArtistMeta) -> Result<ArtistId, SaveError>;
}
/// Null database implementation of [`IDatabase`].
@ -35,6 +38,10 @@ impl IDatabase for NullDatabase {
fn save(&mut self, _collection: &Collection) -> Result<(), SaveError> {
Ok(())
}
fn insert_artist(&mut self, _: &ArtistMeta) -> Result<ArtistId,SaveError> {
Ok(ArtistId(0))
}
}
/// Error type for database calls.

291
src/core/musichoard/base.rs
View File

@ -5,7 +5,7 @@ use crate::core::{
merge::{MergeCollections, NormalMap},
string, Collection,
},
musichoard::{filter::CollectionFilter, Error, MusicHoard},
musichoard::{filter::CollectionFilter, Error, LibArtist, MusicHoard},
};
pub trait IMusicHoardBase {
@ -30,7 +30,7 @@ impl<Database, Library> IMusicHoardBase for MusicHoard<Database, Library> {
}
pub trait IMusicHoardBasePrivate {
fn sort_albums_and_tracks<'a, C: Iterator<Item = &'a mut Artist>>(collection: C);
fn sort_albums_and_tracks<'a, COL: Iterator<Item = &'a mut Vec<Album>>>(collection: COL);
fn merge_collections<It: IntoIterator<Item = Artist>>(&self, database: It) -> Collection;
fn filter_collection(&self) -> Collection;
@ -54,30 +54,32 @@ pub trait IMusicHoardBasePrivate {
}
impl<Database, Library> IMusicHoardBasePrivate for MusicHoard<Database, Library> {
fn sort_albums_and_tracks<'a, COL: Iterator<Item = &'a mut Artist>>(collection: COL) {
for artist in collection {
artist.albums.sort_unstable();
for album in artist.albums.iter_mut() {
fn sort_albums_and_tracks<'a, COL: Iterator<Item = &'a mut Vec<Album>>>(collection: COL) {
for albums in collection {
albums.sort_unstable();
for album in albums.iter_mut() {
album.tracks.sort_unstable();
}
}
}
fn merge_collections<It: IntoIterator<Item = Artist>>(&self, database: It) -> Collection {
let mut primary = NormalMap::<Artist>::new();
let mut primary = NormalMap::<LibArtist>::new();
let mut secondary = NormalMap::<Artist>::new();
for artist in self.library_cache.iter().cloned() {
primary.insert(string::normalize_string(&artist.meta.id.name), artist);
for (normal_name, artist) in self.library_cache.clone().into_iter() {
primary.insert(normal_name, artist);
}
for artist in database.into_iter() {
secondary.insert(string::normalize_string(&artist.meta.id.name), artist);
secondary.insert(string::normalize_string(&artist.meta.name), artist);
}
let mut collection = MergeCollections::merge_by_name(primary, secondary);
collection.sort_unstable();
let (mut collection, left) = MergeCollections::merge_by_name(primary, secondary);
// TODO: Insert what's left into the DB to get IDs and then append to collection.
collection.sort_unstable();
collection
}
@ -95,15 +97,18 @@ impl<Database, Library> IMusicHoardBasePrivate for MusicHoard<Database, Library>
return None;
}
let meta = artist.meta.clone();
Some(Artist { meta, albums })
Some(Artist {
id: artist.id,
meta: artist.meta.clone(),
albums,
})
}
fn get_artist_mut<'a>(
collection: &'a mut Collection,
artist_id: &ArtistId,
) -> Option<&'a mut Artist> {
collection.iter_mut().find(|a| &a.meta.id == artist_id)
collection.iter_mut().find(|a| &a.id == artist_id)
}
fn get_artist_mut_or_err<'a>(
@ -138,180 +143,224 @@ impl<Database, Library> IMusicHoardBasePrivate for MusicHoard<Database, Library>
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use crate::{
collection::{album::AlbumPrimaryType, artist::ArtistMeta},
core::testmod::FULL_COLLECTION,
collection::{
album::AlbumPrimaryType,
artist::{ArtistMeta, ArtistName},
},
core::{musichoard::LibArtist, testmod::FULL_COLLECTION},
filter::AlbumField,
};
use super::*;
#[test]
#[ignore]
// TODO: figure out how to do a merge
fn merge_collection_no_overlap() {
let half: usize = FULL_COLLECTION.len() / 2;
// let half: usize = FULL_COLLECTION.len() / 2;
let left = FULL_COLLECTION[..half].to_owned();
let right = FULL_COLLECTION[half..].to_owned();
// let left = FULL_COLLECTION[..half].to_owned();
// let right = FULL_COLLECTION[half..].to_owned();
let mut expected = FULL_COLLECTION.to_owned();
expected.sort_unstable();
// let mut expected = FULL_COLLECTION.to_owned();
// expected.sort_unstable();
let mut mh = MusicHoard {
library_cache: left.clone(),
..Default::default()
};
// let mut mh = MusicHoard {
// library_cache: left.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(right.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(right.clone());
// assert_eq!(expected, mh.collection);
// The merge is completely non-overlapping so it should be commutative.
let mut mh = MusicHoard {
library_cache: right.clone(),
..Default::default()
};
// // The merge is completely non-overlapping so it should be commutative.
// let mut mh = MusicHoard {
// library_cache: right.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(left.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(left.clone());
// assert_eq!(expected, mh.collection);
}
#[test]
#[ignore]
// TODO: figure out how to do a merge
fn merge_collection_overlap() {
let half: usize = FULL_COLLECTION.len() / 2;
// let half: usize = FULL_COLLECTION.len() / 2;
let left = FULL_COLLECTION[..(half + 1)].to_owned();
let right = FULL_COLLECTION[half..].to_owned();
// let left = FULL_COLLECTION[..(half + 1)].to_owned();
// let right = FULL_COLLECTION[half..].to_owned();
let mut expected = FULL_COLLECTION.to_owned();
expected.sort_unstable();
// let mut expected = FULL_COLLECTION.to_owned();
// expected.sort_unstable();
let mut mh = MusicHoard {
library_cache: left.clone(),
..Default::default()
};
// let mut mh = MusicHoard {
// library_cache: left.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(right.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(right.clone());
// assert_eq!(expected, mh.collection);
// The merge does not overwrite any data so it should be commutative.
let mut mh = MusicHoard {
library_cache: right.clone(),
..Default::default()
};
// // The merge does not overwrite any data so it should be commutative.
// let mut mh = MusicHoard {
// library_cache: right.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(left.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(left.clone());
// assert_eq!(expected, mh.collection);
}
#[test]
#[ignore]
// TODO: figure out how to do a merge
fn merge_collection_incompatible_sorting() {
// It may be that the same artist in one collection has a "sort" field defined while the
// same artist in the other collection does not. This means that the two collections are not
// sorted consistently. If the merge assumes they are sorted consistently this will lead to
// the same artist appearing twice in the final list. This should not be the case.
// // It may be that the same artist in one collection has a "sort" field defined while the
// // same artist in the other collection does not. This means that the two collections are not
// // sorted consistently. If the merge assumes they are sorted consistently this will lead to
// // the same artist appearing twice in the final list. This should not be the case.
// We will mimic this situation by taking the last artist from FULL_COLLECTION and giving it
// a sorting name that would place it in the beginning.
let left = FULL_COLLECTION.to_owned();
let mut right: Vec<Artist> = vec![left.last().unwrap().clone()];
// // We will mimic this situation by taking the last artist from FULL_COLLECTION and giving it
// // a sorting name that would place it in the beginning.
// let left = FULL_COLLECTION.to_owned();
// let mut right: Vec<Artist> = vec![left.last().unwrap().clone()];
assert!(right.first().unwrap() > left.first().unwrap());
let artist_sort = Some(String::from("Album_Artist 0"));
right[0].meta.info.sort = artist_sort.clone();
assert!(right.first().unwrap() < left.first().unwrap());
// assert!(right.first().unwrap() > left.first().unwrap());
// let artist_sort = Some(String::from("Album_Artist 0"));
// right[0].meta.info.sort = artist_sort.clone();
// assert!(right.first().unwrap() < left.first().unwrap());
// The result of the merge should be the same list of artists, but with the last artist now
// in first place.
let mut expected = left.to_owned();
expected.last_mut().as_mut().unwrap().meta.info.sort = artist_sort.clone();
expected.rotate_right(1);
// // The result of the merge should be the same list of artists, but with the last artist now
// // in first place.
// let mut expected = left.to_owned();
// expected.last_mut().as_mut().unwrap().meta.info.sort = artist_sort.clone();
// expected.rotate_right(1);
let mut mh = MusicHoard {
library_cache: left.clone(),
..Default::default()
};
// let mut mh = MusicHoard {
// library_cache: left.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(right.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(right.clone());
// assert_eq!(expected, mh.collection);
// The merge overwrites the sort data, but no data is erased so it should be commutative.
let mut mh = MusicHoard {
library_cache: right.clone(),
..Default::default()
};
// // The merge overwrites the sort data, but no data is erased so it should be commutative.
// let mut mh = MusicHoard {
// library_cache: right.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(left.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(left.clone());
// assert_eq!(expected, mh.collection);
}
#[test]
#[ignore]
// TODO: figure out how to do a merge
#[should_panic(expected = "multiple secondaries unsupported")]
fn merge_two_db_artists_to_one_lib_artist() {
let mut left = Collection::new();
let mut right = Collection::new();
// let mut left = HashMap::<String, LibArtist>::new();
// let mut right = Collection::new();
let artist = Artist::new(ArtistId::new("Artist"));
// let name = ArtistName::new("Artist");
left.push(artist.clone());
right.push(artist.clone());
right.push(artist.clone());
// left.insert(
// name.official.clone(),
// LibArtist {
// meta: ArtistMeta::new(name.clone()),
// albums: vec![],
// },
// );
// right.push(Artist::new(1, name.clone()));
// right.push(Artist::new(2, name.clone()));
let mut mh = MusicHoard {
library_cache: left.clone(),
..Default::default()
};
// let mut mh = MusicHoard {
// library_cache: left.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(right.clone());
// mh.collection = mh.merge_collections(right.clone());
}
#[test]
#[ignore]
// TODO: change to albums - primary clash is not possible for artists since without a lib id
#[should_panic(expected = "multiple primaries unsupported")]
fn merge_one_db_artist_to_two_lib_artists() {
let mut left = Collection::new();
let mut right = Collection::new();
// let mut left = Collection::new();
// let mut right = Collection::new();
let artist = Artist::new(ArtistId::new("Artist"));
// let artist = Artist::new(ArtistId::new("Artist"));
left.push(artist.clone());
left.push(artist.clone());
right.push(artist.clone());
// left.insert(
// name.official.clone(),
// LibArtist {
// name: name.clone(),
// meta: ArtistMeta::default(),
// albums: vec![],
// },
// );
// left.insert(
// name.official.clone(),
// LibArtist {
// name: name.clone(),
// meta: ArtistMeta::default(),
// albums: vec![],
// },
// );
// right.push(artist.clone());
let mut mh = MusicHoard {
library_cache: left.clone(),
..Default::default()
};
// let mut mh = MusicHoard {
// library_cache: left.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(right.clone());
// mh.collection = mh.merge_collections(right.clone());
}
#[test]
#[ignore]
// TODO: figue out how to do a merge
fn merge_normalized_artist_names() {
let mut left = Collection::new();
let mut right = Collection::new();
// let mut left = HashMap::<String, LibArtist>::new();
// let mut right = Collection::new();
left.push(Artist::new(ArtistId::new("Artist‐Name ‘Name’")));
// let left_name = "Artist‐Name ‘Name’";
// left.insert(
// String::from(left_name),
// LibArtist {
// meta: ArtistMeta::new(left_name.into()),
// albums: vec![],
// },
// );
right.push(Artist::new(ArtistId::new("arTist—naMe 'name’")));
right.push(Artist::new(ArtistId::new("Artist‐Name “Name”")));
// right.push(Artist::new(1, "arTist—naMe 'name’"));
// right.push(Artist::new(2, "Artist‐Name “Name”"));
// The first artist will be merged, the second will be added.
let mut expected = left.clone();
expected.push(right.last().unwrap().clone());
expected.sort_unstable();
// // The first artist will be merged preserving the name, the second will be added.
// let mut expected = right.clone();
// expected.first_mut().unwrap().meta.name = left["Artist‐Name ‘Name’"].meta.name.clone();
let mut mh = MusicHoard {
library_cache: left.clone(),
..Default::default()
};
// let mut mh = MusicHoard {
// library_cache: left.clone(),
// ..Default::default()
// };
mh.collection = mh.merge_collections(right.clone());
assert_eq!(expected, mh.collection);
// mh.collection = mh.merge_collections(right.clone());
// assert_eq!(expected, mh.collection);
}
#[test]
fn filtered() {
let mut mh = MusicHoard {
collection: vec![Artist {
meta: ArtistMeta::new(ArtistId::new("Artist")),
id: 0.into(),
meta: ArtistMeta::new("Artist"),
albums: vec![
Album::new(AlbumId::new("Album 1")),
Album::new(AlbumId::new("Album 2")),

10
src/core/musichoard/builder.rs
View File

@ -1,3 +1,5 @@
use std::collections::HashMap;
use crate::core::{
interface::{database::IDatabase, library::ILibrary},
musichoard::{CollectionFilter, MusicHoard, NoDatabase, NoLibrary},
@ -67,7 +69,7 @@ impl MusicHoard<NoDatabase, NoLibrary> {
collection: vec![],
database: NoDatabase,
library: NoLibrary,
library_cache: vec![],
library_cache: HashMap::new(),
}
}
}
@ -88,7 +90,7 @@ impl<Library: ILibrary> MusicHoard<NoDatabase, Library> {
collection: vec![],
database: NoDatabase,
library,
library_cache: vec![],
library_cache: HashMap::new(),
}
}
}
@ -109,7 +111,7 @@ impl<Database: IDatabase> MusicHoard<Database, NoLibrary> {
collection: vec![],
database,
library: NoLibrary,
library_cache: vec![],
library_cache: HashMap::new(),
}
}
}
@ -130,7 +132,7 @@ impl<Database: IDatabase, Library: ILibrary> MusicHoard<Database, Library> {
collection: vec![],
database,
library,
library_cache: vec![],
library_cache: HashMap::new(),
}
}
}

52
src/core/musichoard/database.rs
View File

@ -66,7 +66,7 @@ pub trait IMusicHoardDatabase {
impl<Database: IDatabase, Library> IMusicHoardDatabase for MusicHoard<Database, Library> {
fn reload_database(&mut self) -> Result<(), Error> {
let mut database_cache = self.database.load()?;
Self::sort_albums_and_tracks(database_cache.iter_mut());
Self::sort_albums_and_tracks(database_cache.iter_mut().map(|a| &mut a.albums));
self.collection = self.merge_collections(database_cache);
self.filtered = self.filter_collection();
@ -297,7 +297,7 @@ mod tests {
let database = MockIDatabase::new();
let mut music_hoard = MusicHoard::database(database);
let artist_id = ArtistId::new("an artist");
let artist_id = ArtistId(1);
let actual_err = music_hoard
.merge_artist_info(&artist_id, ArtistInfo::default())
.unwrap_err();
@ -312,12 +312,12 @@ mod tests {
let mut database = MockIDatabase::new();
database.expect_save().times(2).returning(|_| Ok(()));
let artist_id = ArtistId::new("an artist");
let artist_id_2 = ArtistId::new("another artist");
let artist = Artist::new(1, "an artist");
let artist_2 = Artist::new(2, "another artist");
let mb_ref = ArtistMbRef::Some(MbArtistRef::from_uuid_str(MBID).unwrap());
let mut music_hoard = MusicHoard::database(database);
music_hoard.collection.push(Artist::new(artist_id.clone()));
music_hoard.collection.push(artist.clone());
music_hoard.collection.sort_unstable();
let mut expected = ArtistInfo::default();
@ -328,13 +328,13 @@ mod tests {
// Setting info on an artist not in the collection is an error.
assert!(music_hoard
.merge_artist_info(&artist_id_2, info.clone())
.merge_artist_info(&artist_2.id, info.clone())
.is_err());
assert_eq!(music_hoard.collection[0].meta.info, expected);
// Setting info on an artist.
assert!(music_hoard
.merge_artist_info(&artist_id, info.clone())
.merge_artist_info(&artist.id, info.clone())
.is_ok());
expected.mb_ref = mb_ref.clone();
expected.properties.insert(
@ -344,11 +344,11 @@ mod tests {
assert_eq!(music_hoard.collection[0].meta.info, expected);
// Clearing info on an artist that does not exist is an error.
assert!(music_hoard.clear_artist_info(&artist_id_2).is_err());
assert!(music_hoard.clear_artist_info(&artist_2.id).is_err());
assert_eq!(music_hoard.collection[0].meta.info, expected);
// Clearing info.
assert!(music_hoard.clear_artist_info(&artist_id).is_ok());
assert!(music_hoard.clear_artist_info(&artist.id).is_ok());
expected.mb_ref.take();
expected.properties.clear();
assert_eq!(music_hoard.collection[0].meta.info, expected);
@ -362,7 +362,7 @@ mod tests {
let album_meta_2 = AlbumMeta::new(album_id_2);
let collection = FULL_COLLECTION.to_owned();
let artist_id = collection[0].meta.id.clone();
let artist_id = collection[0].id;
let mut with_album = collection.clone();
with_album[0].albums.push(Album::new(album_id));
with_album[0].albums.sort_unstable();
@ -415,11 +415,11 @@ mod tests {
fn set_clear_album_mb_ref() {
let mut database = MockIDatabase::new();
let artist_id = ArtistId::new("an artist");
let artist = Artist::new(1, "an artist");
let mut album_id = AlbumId::new("an album");
let album_id_2 = AlbumId::new("another album");
let mut database_result = vec![Artist::new(artist_id.clone())];
let mut database_result = vec![artist.clone()];
database_result[0].albums.push(Album::new(album_id.clone()));
database
@ -435,27 +435,27 @@ mod tests {
// Seting mb_ref on an album not belonging to the artist is an error.
assert!(music_hoard
.set_album_mb_ref(&artist_id, &album_id_2, AlbumMbRef::CannotHaveMbid)
.set_album_mb_ref(&artist.id, &album_id_2, AlbumMbRef::CannotHaveMbid)
.is_err());
let album = &music_hoard.collection[0].albums[0];
assert_eq!(album.meta.id.mb_ref, AlbumMbRef::None);
// Set mb_ref.
assert!(music_hoard
.set_album_mb_ref(&artist_id, &album_id, AlbumMbRef::CannotHaveMbid)
.set_album_mb_ref(&artist.id, &album_id, AlbumMbRef::CannotHaveMbid)
.is_ok());
let album = &music_hoard.collection[0].albums[0];
assert_eq!(album.meta.id.mb_ref, AlbumMbRef::CannotHaveMbid);
// Clearing mb_ref on an album that does not exist is an error.
assert!(music_hoard
.clear_album_mb_ref(&artist_id, &album_id_2)
.clear_album_mb_ref(&artist.id, &album_id_2)
.is_err());
// Clearing mb_ref from an album without the mb_ref set is an error. Effectively the album
// does not exist.
assert!(music_hoard
.clear_album_mb_ref(&artist_id, &album_id)
.clear_album_mb_ref(&artist.id, &album_id)
.is_err());
let album = &music_hoard.collection[0].albums[0];
assert_eq!(album.meta.id.mb_ref, AlbumMbRef::CannotHaveMbid);
@ -464,7 +464,7 @@ mod tests {
// album.
album_id.set_mb_ref(AlbumMbRef::CannotHaveMbid);
assert!(music_hoard
.clear_album_mb_ref(&artist_id, &album_id)
.clear_album_mb_ref(&artist.id, &album_id)
.is_ok());
let album = &music_hoard.collection[0].albums[0];
assert_eq!(album.meta.id.mb_ref, AlbumMbRef::None);
@ -474,11 +474,11 @@ mod tests {
fn set_clear_album_info() {
let mut database = MockIDatabase::new();
let artist_id = ArtistId::new("an artist");
let artist = Artist::new(1, "an artist");
let album_id = AlbumId::new("an album");
let album_id_2 = AlbumId::new("another album");
let mut database_result = vec![Artist::new(artist_id.clone())];
let mut database_result = vec![artist.clone()];
database_result[0].albums.push(Album::new(album_id.clone()));
database
@ -499,25 +499,25 @@ mod tests {
// Seting info on an album not belonging to the artist is an error.
assert!(music_hoard
.merge_album_info(&artist_id, &album_id_2, info.clone())
.merge_album_info(&artist.id, &album_id_2, info.clone())
.is_err());
let meta = &music_hoard.collection[0].albums[0].meta;
assert_eq!(meta.info, AlbumInfo::default());
// Set info.
assert!(music_hoard
.merge_album_info(&artist_id, &album_id, info.clone())
.merge_album_info(&artist.id, &album_id, info.clone())
.is_ok());
let meta = &music_hoard.collection[0].albums[0].meta;
assert_eq!(meta.info, info);
// Clearing info on an album that does not exist is an error.
assert!(music_hoard
.clear_album_info(&artist_id, &album_id_2)
.clear_album_info(&artist.id, &album_id_2)
.is_err());
// Clear info.
assert!(music_hoard.clear_album_info(&artist_id, &album_id).is_ok());
assert!(music_hoard.clear_album_info(&artist.id, &album_id).is_ok());
let meta = &music_hoard.collection[0].albums[0].meta;
assert_eq!(meta.info, AlbumInfo::default());
}
@ -583,11 +583,11 @@ mod tests {
let mut music_hoard = MusicHoard::database(database);
music_hoard.reload_database().unwrap();
let artist_id = ArtistId::new("an artist");
music_hoard.collection.push(Artist::new(artist_id.clone()));
let artist = Artist::new(1, "an artist");
music_hoard.collection.push(artist.clone());
let actual_err = music_hoard
.add_album(artist_id, AlbumMeta::new("an album"))
.add_album(artist.id, AlbumMeta::new("an album"))
.unwrap_err();
let expected_err = Error::DatabaseError(
database::SaveError::IoError(String::from("I/O error")).to_string(),

48
src/core/musichoard/library.rs
View File

@ -1,9 +1,10 @@
use std::collections::HashMap;
use crate::core::{
use crate::{
collection::string::{self, NormalString},
core::{
collection::{
album::{Album, AlbumDate, AlbumId, AlbumMbRef},
artist::{Artist, ArtistId},
track::{Track, TrackId, TrackNum, TrackQuality},
Collection,
},
@ -12,8 +13,9 @@ use crate::core::{
library::{ILibrary, Item, Query},
},
musichoard::{
base::IMusicHoardBasePrivate, database::IMusicHoardDatabasePrivate, Error, MusicHoard,
NoDatabase,
base::IMusicHoardBasePrivate, database::IMusicHoardDatabasePrivate, Error, LibArtist,
MusicHoard, NoDatabase,
},
},
};
@ -31,7 +33,7 @@ impl<Library: ILibrary> IMusicHoardLibrary for MusicHoard<NoDatabase, Library> {
impl<Database: IDatabase, Library: ILibrary> IMusicHoardLibrary for MusicHoard<Database, Library> {
fn rescan_library(&mut self) -> Result<(), Error> {
let mut database_cache = self.database.load()?;
Self::sort_albums_and_tracks(database_cache.iter_mut());
Self::sort_albums_and_tracks(database_cache.iter_mut().map(|a| &mut a.albums));
self.collection = self.rescan_library_inner(database_cache)?;
self.commit()
@ -42,20 +44,17 @@ impl<Database, Library: ILibrary> MusicHoard<Database, Library> {
fn rescan_library_inner(&mut self, database: Collection) -> Result<Collection, Error> {
let items = self.library.list(&Query::new())?;
self.library_cache = Self::items_to_artists(items)?;
Self::sort_albums_and_tracks(self.library_cache.iter_mut());
Self::sort_albums_and_tracks(self.library_cache.values_mut().map(|la| &mut la.albums));
Ok(self.merge_collections(database))
}
fn items_to_artists(items: Vec<Item>) -> Result<Collection, Error> {
let mut collection = HashMap::<ArtistId, Artist>::new();
fn items_to_artists(items: Vec<Item>) -> Result<HashMap<NormalString, LibArtist>, Error> {
let mut collection = HashMap::<NormalString, LibArtist>::new();
for item in items.into_iter() {
let artist_id = ArtistId {
name: item.album_artist,
};
let artist_sort = item.album_artist_sort;
let artist_name_official = item.album_artist;
let artist_name_sort = item.album_artist_sort;
let album_id = AlbumId {
title: item.album_title,
@ -84,24 +83,25 @@ impl<Database, Library: ILibrary> MusicHoard<Database, Library> {
// There are usually many entries per artist. Therefore, we avoid simply calling
// .entry(artist_id.clone()).or_insert_with(..), because of the clone. The flipside is
// that insertions will thus do an additional lookup.
let artist = match collection.get_mut(&artist_id) {
let normal_name = string::normalize_string(&artist_name_official);
let artist = match collection.get_mut(&normal_name) {
Some(artist) => artist,
None => collection
.entry(artist_id.clone())
.or_insert_with(|| Artist::new(artist_id)),
.entry(normal_name)
.or_insert_with(|| LibArtist::new(artist_name_official)),
};
if artist.meta.info.sort.is_some() {
if artist_sort.is_some() && (artist.meta.info.sort != artist_sort) {
if artist.meta.sort.is_some() {
if artist_name_sort.is_some() && (artist.meta.sort != artist_name_sort) {
return Err(Error::CollectionError(format!(
"multiple album_artist_sort found for artist '{}': '{}' != '{}'",
artist.meta.id,
artist.meta.info.sort.as_ref().unwrap(),
artist_sort.as_ref().unwrap()
artist.meta.name,
artist.meta.sort.as_ref().unwrap(),
artist_name_sort.as_ref().unwrap()
)));
}
} else if artist_sort.is_some() {
artist.meta.info.sort = artist_sort;
} else if artist_name_sort.is_some() {
artist.meta.sort = artist_name_sort;
}
// Do a linear search as few artists have more than a handful of albums. Search from the
@ -121,7 +121,7 @@ impl<Database, Library: ILibrary> MusicHoard<Database, Library> {
}
}
Ok(collection.into_values().collect())
Ok(collection)
}
}

44
src/core/musichoard/mod.rs
View File

@ -12,10 +12,19 @@ pub use database::IMusicHoardDatabase;
pub use filter::CollectionFilter;
pub use library::IMusicHoardLibrary;
use std::fmt::{self, Display};
use std::{
collections::HashMap,
fmt::{self, Display},
};
use crate::core::{
collection::Collection,
collection::{
album::Album,
artist::{Artist, ArtistId, ArtistMeta, ArtistName},
merge::IntoId,
string::NormalString,
Collection,
},
interface::{
database::{LoadError as DatabaseLoadError, SaveError as DatabaseSaveError},
library::Error as LibraryError,
@ -24,7 +33,6 @@ use crate::core::{
/// The Music Hoard. It is responsible for pulling information from both the library and the
/// database, ensuring its consistent and writing back any changes.
// TODO: Split into inner and external/interfaces to facilitate building.
#[derive(Debug)]
pub struct MusicHoard<Database, Library> {
filter: CollectionFilter,
@ -32,7 +40,35 @@ pub struct MusicHoard<Database, Library> {
collection: Collection,
database: Database,
library: Library,
library_cache: Collection,
library_cache: HashMap<NormalString, LibArtist>,
}
#[derive(Clone, Debug)]
struct LibArtist {
meta: ArtistMeta,
albums: Vec<Album>,
}
impl LibArtist {
fn new<Name: Into<ArtistName>>(name: Name) -> Self {
LibArtist {
meta: ArtistMeta::new(name),
albums: vec![],
}
}
}
impl IntoId for LibArtist {
type Id = ArtistId;
type IdSelf = Artist;
fn into_id(self, id: &Self::Id) -> Self::IdSelf {
Artist {
id: *id,
meta: self.meta,
albums: self.albums,
}
}
}
/// Phantom type for when a library implementation is not needed.

6
src/external/database/serde/deserialize.rs
View File

@ -34,6 +34,7 @@ impl From<DeserializeDatabase> for Collection {
#[derive(Clone, Debug, Deserialize)]
pub struct DeserializeArtist {
pub id: usize,
pub name: String,
pub mb_ref: DeserializeMbRefOption,
pub sort: Option<String>,
@ -117,12 +118,11 @@ impl From<DeserializeArtist> for Artist {
let mut albums: Vec<Album> = artist.albums.into_iter().map(Into::into).collect();
albums.sort_unstable();
Artist {
id: ArtistId(artist.id),
meta: ArtistMeta {
id: ArtistId {
name: artist.name,
},
info: ArtistInfo {
sort: artist.sort,
info: ArtistInfo {
mb_ref: artist.mb_ref.into(),
properties: artist.properties,
},

25
src/external/database/serde/serialize.rs
View File

@ -4,7 +4,12 @@ use serde::Serialize;
use crate::{
collection::musicbrainz::{MbRefOption, Mbid},
core::collection::{album::Album, artist::Artist, musicbrainz::IMusicBrainzRef, Collection},
core::collection::{
album::Album,
artist::{Artist, ArtistMeta},
musicbrainz::IMusicBrainzRef,
Collection,
},
external::database::serde::common::{
MbRefOptionDef, SerdeAlbumDate, SerdeAlbumLibId, SerdeAlbumPrimaryType,
SerdeAlbumSecondaryType,
@ -73,12 +78,20 @@ impl Serialize for SerializeMbid<'_> {
impl<'a> From<&'a Artist> for SerializeArtist<'a> {
fn from(artist: &'a Artist) -> Self {
let mut sa: SerializeArtist = (&artist.meta).into();
sa.albums = artist.albums.iter().map(Into::into).collect();
sa
}
}
impl<'a> From<&'a ArtistMeta> for SerializeArtist<'a> {
fn from(meta: &'a ArtistMeta) -> Self {
SerializeArtist {
name: &artist.meta.id.name,
mb_ref: (&artist.meta.info.mb_ref).into(),
sort: &artist.meta.info.sort,
properties: &artist.meta.info.properties,
albums: artist.albums.iter().map(Into::into).collect(),
name: &meta.name,
mb_ref: (&meta.info.mb_ref).into(),
sort: &meta.sort,
properties: &meta.info.properties,
albums: vec![],
}
}
}

41
src/external/database/sql/backend.rs
View File

@ -166,14 +166,10 @@ impl ISqlTransactionBackend for SqlTransactionSqliteBackend<'_> {
.transpose()
}
fn insert_artist(&self, artist: &SerializeArtist<'_>) -> Result<(), Error> {
fn insert_artist(&self, artist: &SerializeArtist<'_>) -> Result<i64, Error> {
let mut stmt = self.prepare_cached(
"INSERT INTO artists (name, mbid, sort, properties)
VALUES (?1, ?2, ?3, ?4)
ON CONFLICT(name, mbid) DO UPDATE SET sort = ?3, properties = ?4
WHERE EXISTS (
SELECT 1 EXCEPT SELECT 1 WHERE sort = ?3 AND properties = ?4
)",
VALUES (?1, ?2, ?3, ?4)",
);
Self::execute(
&mut stmt,
@ -183,20 +179,43 @@ impl ISqlTransactionBackend for SqlTransactionSqliteBackend<'_> {
artist.sort,
serde_json::to_string(&artist.properties)?,
),
)?;
Ok(self.tx.last_insert_rowid())
}
fn update_artist(&self, oid: i64, artist: &SerializeArtist<'_>) -> Result<(), Error> {
let mut stmt = self.prepare_cached(
"UPDATE SET name = ?2, mbid = ?3, sort = ?4, properties = ?5
WHERE rowid = ?1 EXISTS (
SELECT 1 EXCEPT SELECT 1 WHERE
name = ?2 AND mbid = ?3 AND sort = ?4 AND properties = ?5
)",
);
Self::execute(
&mut stmt,
(
oid,
artist.name,
serde_json::to_string(&artist.mb_ref)?,
artist.sort,
serde_json::to_string(&artist.properties)?,
),
)
}
fn select_all_artists(&self) -> Result<Vec<DeserializeArtist>, Error> {
let mut stmt = self.prepare_cached("SELECT name, mbid, sort, properties FROM artists");
let mut stmt =
self.prepare_cached("SELECT rowid, name, mbid, sort, properties FROM artists");
let mut rows = Self::query(&mut stmt, ())?;
let mut artists = vec![];
while let Some(row) = Self::next_row(&mut rows)? {
artists.push(DeserializeArtist {
name: Self::get_value(row, 0)?,
mb_ref: serde_json::from_str(&Self::get_value::<String>(row, 1)?)?,
sort: Self::get_value(row, 2)?,
properties: serde_json::from_str(&Self::get_value::<String>(row, 3)?)?,
id: Self::get_value::<i64>(row, 0)? as usize,
name: Self::get_value(row, 1)?,
mb_ref: serde_json::from_str(&Self::get_value::<String>(row, 2)?)?,
sort: Self::get_value(row, 3)?,
properties: serde_json::from_str(&Self::get_value::<String>(row, 4)?)?,
albums: vec![],
});
}

34
src/external/database/sql/mod.rs
View File

@ -9,7 +9,10 @@ use mockall::automock;
use crate::{
core::{
collection::Collection,
collection::{
artist::{ArtistId, ArtistMeta},
Collection,
},
interface::database::{IDatabase, LoadError, SaveError},
},
external::database::serde::{
@ -60,7 +63,11 @@ pub trait ISqlTransactionBackend {
/// Insert an artist into the artist table.
#[allow(clippy::needless_lifetimes)] // Conflicts with automock.
fn insert_artist<'a>(&self, artist: &SerializeArtist<'a>) -> Result<(), Error>;
fn insert_artist<'a>(&self, artist: &SerializeArtist<'a>) -> Result<i64, Error>;
/// Update an artist in the artist table.
#[allow(clippy::needless_lifetimes)] // Conflicts with automock.
fn update_artist<'a>(&self, oid: i64, artist: &SerializeArtist<'a>) -> Result<(), Error>;
/// Get all artists from the artist table.
fn select_all_artists(&self) -> Result<Vec<DeserializeArtist>, Error>;
@ -204,6 +211,16 @@ impl<SDB: for<'conn> ISqlDatabaseBackend<'conn>> IDatabase for SqlDatabase<SDB>
tx.commit()?;
Ok(())
}
fn insert_artist(&mut self, artist: &ArtistMeta) -> Result<ArtistId, SaveError> {
let tx = self.backend.transaction()?;
let sa: SerializeArtist = artist.into();
let oid = tx.insert_artist(&sa)?;
tx.commit()?;
Ok(ArtistId(oid as usize))
}
}
#[cfg(test)]
@ -211,7 +228,7 @@ pub mod testmod;
#[cfg(test)]
mod tests {
use std::collections::VecDeque;
use std::{collections::VecDeque, ops::AddAssign};
use mockall::{predicate, Sequence};
@ -326,12 +343,15 @@ mod tests {
let mut seq = Sequence::new();
expect_create!(tx, seq);
then1!(tx, seq, expect_insert_database_version).with(predicate::eq(V20250103));
let mut rowid: i64 = 0;
for artist in write_data.iter() {
let ac = artist.clone();
then1!(tx, seq, expect_insert_artist)
rowid.add_assign(1);
then!(tx, seq, expect_insert_artist)
.return_once(move |_| Ok(rowid))
.withf(move |a| a == &Into::<SerializeArtist>::into(&ac));
for album in artist.albums.iter() {
let (nc, ac) = (artist.meta.id.name.clone(), album.clone());
let (nc, ac) = (artist.meta.name.clone(), album.clone());
then2!(tx, seq, expect_insert_album)
.withf(move |n, a| n == nc && a == &Into::<SerializeAlbum>::into(&ac));
}
@ -354,9 +374,9 @@ mod tests {
then!(tx, seq, expect_select_all_artists).return_once(|| Ok(de_artists));
for artist in artists.iter() {
let de_albums = DATABASE_SQL_ALBUMS.get(&artist.meta.id.name).unwrap();
let de_albums = DATABASE_SQL_ALBUMS.get(&artist.meta.name).unwrap();
then!(tx, seq, expect_select_artist_albums)
.with(predicate::eq(artist.meta.id.name.clone()))
.with(predicate::eq(artist.meta.name.clone()))
.return_once(|_| Ok(de_albums.to_owned()));
}

4
src/external/database/sql/testmod.rs
View File

@ -20,6 +20,7 @@ pub static DATABASE_SQL_VERSION: &str = "V20250103";
pub static DATABASE_SQL_ARTISTS: Lazy<Vec<DeserializeArtist>> = Lazy::new(|| {
vec![
DeserializeArtist {
id: 1,
name: String::from("Album_Artist ‘A’"),
mb_ref: DeserializeMbRefOption(MbRefOption::Some(DeserializeMbid(
"00000000-0000-0000-0000-000000000000".try_into().unwrap(),
@ -42,6 +43,7 @@ pub static DATABASE_SQL_ARTISTS: Lazy<Vec<DeserializeArtist>> = Lazy::new(|| {
albums: vec![],
},
DeserializeArtist {
id: 2,
name: String::from("Album_Artist ‘B’"),
mb_ref: DeserializeMbRefOption(MbRefOption::Some(DeserializeMbid(
"11111111-1111-1111-1111-111111111111".try_into().unwrap(),
@ -64,6 +66,7 @@ pub static DATABASE_SQL_ARTISTS: Lazy<Vec<DeserializeArtist>> = Lazy::new(|| {
albums: vec![],
},
DeserializeArtist {
id: 3,
name: String::from("The Album_Artist ‘C’"),
mb_ref: DeserializeMbRefOption(MbRefOption::CannotHaveMbid),
sort: Some(String::from("Album_Artist ‘C’, The")),
@ -71,6 +74,7 @@ pub static DATABASE_SQL_ARTISTS: Lazy<Vec<DeserializeArtist>> = Lazy::new(|| {
albums: vec![],
},
DeserializeArtist {
id: 4,
name: String::from("Album_Artist ‘D’"),
mb_ref: DeserializeMbRefOption(MbRefOption::None),
sort: None,

20
src/testmod/full.rs
View File

@ -2,12 +2,11 @@ macro_rules! full_collection {
() => {
vec![
Artist {
id: ArtistId(1),
meta: ArtistMeta {
id: ArtistId {
name: "Album_Artist ‘A’".to_string(),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/00000000-0000-0000-0000-000000000000"
).unwrap()),
@ -128,12 +127,11 @@ macro_rules! full_collection {
],
},
Artist {
id: ArtistId(2),
meta: ArtistMeta {
id: ArtistId {
name: "Album_Artist ‘B’".to_string(),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/11111111-1111-1111-1111-111111111111"
).unwrap()),
@ -321,12 +319,11 @@ macro_rules! full_collection {
],
},
Artist {
id: ArtistId(3),
meta: ArtistMeta {
id: ArtistId {
name: "The Album_Artist ‘C’".to_string(),
},
info: ArtistInfo {
sort: Some("Album_Artist ‘C’, The".to_string()),
info: ArtistInfo {
mb_ref: ArtistMbRef::CannotHaveMbid,
properties: HashMap::new(),
},
@ -413,12 +410,11 @@ macro_rules! full_collection {
],
},
Artist {
id: ArtistId(4),
meta: ArtistMeta {
id: ArtistId {
name: "Album_Artist ‘D’".to_string(),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::None,
properties: HashMap::new(),
},

20
src/testmod/library.rs
View File

@ -3,12 +3,11 @@ macro_rules! library_collection {
() => {
vec![
Artist {
id: ArtistId(0),
meta: ArtistMeta {
id: ArtistId {
name: "Album_Artist ‘A’".to_string(),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::None,
properties: HashMap::new(),
},
@ -110,12 +109,11 @@ macro_rules! library_collection {
],
},
Artist {
id: ArtistId(0),
meta: ArtistMeta {
id: ArtistId {
name: "Album_Artist ‘B’".to_string(),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::None,
properties: HashMap::new(),
},
@ -272,12 +270,11 @@ macro_rules! library_collection {
],
},
Artist {
id: ArtistId(0),
meta: ArtistMeta {
id: ArtistId {
name: "The Album_Artist ‘C’".to_string(),
},
info: ArtistInfo {
sort: Some("Album_Artist ‘C’, The".to_string()),
info: ArtistInfo {
mb_ref: ArtistMbRef::None,
properties: HashMap::new(),
},
@ -360,12 +357,11 @@ macro_rules! library_collection {
],
},
Artist {
id: ArtistId(0),
meta: ArtistMeta {
id: ArtistId {
name: "Album_Artist ‘D’".to_string(),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::None,
properties: HashMap::new(),
},

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

@ -6,7 +6,7 @@ use std::{
use musichoard::collection::{
album::{Album, AlbumId, AlbumMeta},
artist::{Artist, ArtistId, ArtistMeta},
artist::{Artist, ArtistId},
musicbrainz::{IMusicBrainzRef, MbArtistRef, MbRefOption, Mbid},
};
@ -14,7 +14,7 @@ use crate::tui::{
app::{
machine::{match_state::MatchState, App, AppInner, AppMachine},
selection::KeySelection,
AppPublicState, AppState, Category, IAppEventFetch, IAppInteractFetch,
AppPublicState, AppState, ArtistMatching, Category, IAppEventFetch, IAppInteractFetch,
},
lib::interface::musicbrainz::daemon::{
EntityList, Error as DaemonError, IMbJobSender, MbApiResult, MbParams, MbReturn,
@ -115,7 +115,7 @@ impl AppMachine<FetchState> {
let mut requests = Self::search_artist_job(artist);
if requests.is_empty() {
fetch = FetchState::fetch(rx);
requests = Self::browse_release_group_job(&artist.meta.info.mb_ref);
requests = Self::browse_release_group_job(artist.id, &artist.meta.info.mb_ref);
} else {
fetch = FetchState::search(rx);
}
@ -130,10 +130,9 @@ impl AppMachine<FetchState> {
Some(album_state) => &artist.albums[album_state.index],
None => return Err("cannot fetch album: no album selected"),
};
let artist_id = &artist.meta.id;
SubmitJob {
fetch: FetchState::search(rx),
requests: Self::search_release_group_job(artist_id, arid, album),
requests: Self::search_release_group_job(artist.id, arid, album),
}
}
};
@ -191,9 +190,9 @@ impl AppMachine<FetchState> {
let selection = KeySelection::get(coll, &inner.selection);
// Find the artist in the full collection to correctly identify already existing albums.
let artist_id = artist.meta.id.clone();
let artist_id = artist.id.clone();
let coll = inner.music_hoard.get_collection();
let artist = coll.iter().find(|a| a.meta.id == artist_id).unwrap();
let artist = coll.iter().find(|a| a.id == artist_id).unwrap();
for new in Self::new_albums(fetch_albums, &artist.albums).into_iter() {
inner.music_hoard.add_album(&artist_id, new)?;
@ -223,11 +222,11 @@ impl AppMachine<FetchState> {
pub fn app_lookup_artist(
inner: AppInner,
fetch: FetchState,
artist: &ArtistMeta,
matching: ArtistMatching,
mbid: Mbid,
) -> App {
let f = Self::submit_lookup_artist_job;
Self::app_lookup(f, inner, fetch, artist, mbid)
Self::app_lookup(f, inner, fetch, matching, mbid)
}
pub fn app_lookup_album(
@ -243,18 +242,18 @@ impl AppMachine<FetchState> {
Self::app_lookup(f, inner, fetch, album_id, mbid)
}
fn app_lookup<F, Meta>(
fn app_lookup<F, Matching>(
submit: F,
inner: AppInner,
mut fetch: FetchState,
meta: Meta,
matching: Matching,
mbid: Mbid,
) -> App
where
F: FnOnce(&dyn IMbJobSender, ResultSender, Meta, Mbid) -> Result<(), DaemonError>,
F: FnOnce(&dyn IMbJobSender, ResultSender, Matching, Mbid) -> Result<(), DaemonError>,
{
let (lookup_tx, lookup_rx) = mpsc::channel::<MbApiResult>();
if let Err(err) = submit(&*inner.musicbrainz, lookup_tx, meta, mbid) {
if let Err(err) = submit(&*inner.musicbrainz, lookup_tx, matching, mbid) {
return AppMachine::error_state(inner, err.to_string()).into();
}
fetch.lookup_rx.replace(lookup_rx);
@ -264,58 +263,70 @@ impl AppMachine<FetchState> {
fn search_artist_job(artist: &Artist) -> VecDeque<MbParams> {
match artist.meta.info.mb_ref {
MbRefOption::Some(ref arid) => {
Self::search_albums_requests(&artist.meta.id, arid, &artist.albums)
Self::search_albums_requests(artist.id, arid, &artist.albums)
}
MbRefOption::CannotHaveMbid => VecDeque::new(),
MbRefOption::None => Self::search_artist_request(&artist.meta),
MbRefOption::None => Self::search_artist_request(ArtistMatching::new(
artist.id,
artist.meta.name.clone(),
)),
}
}
fn search_release_group_job(
artist_id: &ArtistId,
artist_id: ArtistId,
artist_mbid: &MbArtistRef,
album: &Album,
) -> VecDeque<MbParams> {
Self::search_albums_requests(artist_id, artist_mbid, slice::from_ref(album))
}
fn search_artist_request(meta: &ArtistMeta) -> VecDeque<MbParams> {
VecDeque::from([MbParams::search_artist(meta.clone())])
fn search_artist_request(matching: ArtistMatching) -> VecDeque<MbParams> {
VecDeque::from([MbParams::search_artist(matching)])
}
fn search_albums_requests(
artist: &ArtistId,
arid: &MbArtistRef,
artist_id: ArtistId,
artist_mbid: &MbArtistRef,
albums: &[Album],
) -> VecDeque<MbParams> {
let arid = arid.mbid();
let arid = artist_mbid.mbid();
albums
.iter()
.filter(|album| album.meta.id.mb_ref.is_none())
.map(|album| {
MbParams::search_release_group(artist.clone(), arid.clone(), album.meta.clone())
MbParams::search_release_group(artist_id, arid.clone(), album.meta.clone())
})
.collect()
}
fn browse_release_group_job(mbopt: &MbRefOption<MbArtistRef>) -> VecDeque<MbParams> {
fn browse_release_group_job(
artist_id: ArtistId,
mbopt: &MbRefOption<MbArtistRef>,
) -> VecDeque<MbParams> {
match mbopt {
MbRefOption::Some(mbref) => Self::browse_release_group_request(mbref),
MbRefOption::Some(mbref) => Self::browse_release_group_request(artist_id, mbref),
_ => VecDeque::new(),
}
}
fn browse_release_group_request(mbref: &MbArtistRef) -> VecDeque<MbParams> {
VecDeque::from([MbParams::browse_release_group(mbref.mbid().clone())])
fn browse_release_group_request(
artist_id: ArtistId,
mbref: &MbArtistRef,
) -> VecDeque<MbParams> {
VecDeque::from([MbParams::browse_release_group(
artist_id,
mbref.mbid().clone(),
)])
}
fn submit_lookup_artist_job(
musicbrainz: &dyn IMbJobSender,
result_sender: ResultSender,
artist: &ArtistMeta,
matching: ArtistMatching,
mbid: Mbid,
) -> Result<(), DaemonError> {
let requests = VecDeque::from([MbParams::lookup_artist(artist.clone(), mbid)]);
let requests = VecDeque::from([MbParams::lookup_artist(matching, mbid)]);
musicbrainz.submit_foreground_job(result_sender, requests)
}
@ -395,16 +406,18 @@ mod tests {
let mut fetch = FetchState::search(fetch_rx);
fetch.lookup_rx.replace(lookup_rx);
let artist = COLLECTION[3].meta.clone();
let id = COLLECTION[3].id;
let meta = COLLECTION[3].meta.clone();
let matching = ArtistMatching::new(id, meta.name.clone());
let matches: Vec<Entity<ArtistMeta>> = vec![];
let fetch_result = MbReturn::Match(EntityMatches::artist_search(artist.clone(), matches));
let fetch_result = MbReturn::Match(EntityMatches::artist_search(matching.clone(), matches));
fetch_tx.send(Ok(fetch_result.clone())).unwrap();
assert_eq!(fetch.try_recv(), Err(TryRecvError::Empty));
let lookup = Entity::new(artist.clone());
let lookup_result = MbReturn::Match(EntityMatches::artist_lookup(artist.clone(), lookup));
let lookup = Entity::new(meta.clone());
let lookup_result = MbReturn::Match(EntityMatches::artist_lookup(matching.clone(), lookup));
lookup_tx.send(Ok(lookup_result.clone())).unwrap();
assert_eq!(fetch.try_recv(), Ok(Ok(lookup_result)));
@ -445,7 +458,7 @@ mod tests {
fn fetch_single_album() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist_id = COLLECTION[1].meta.id.clone();
let artist_id = COLLECTION[1].id;
let artist_mbid: Mbid = "11111111-1111-1111-1111-111111111111".try_into().unwrap();
let album_meta = COLLECTION[1].albums[0].meta.clone();
@ -520,7 +533,7 @@ mod tests {
fn fetch_albums() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist_id = COLLECTION[1].meta.id.clone();
let artist_id = COLLECTION[1].id;
let artist_mbid: Mbid = "11111111-1111-1111-1111-111111111111".try_into().unwrap();
let album_1_meta = COLLECTION[1].albums[0].meta.clone();
@ -566,7 +579,7 @@ mod tests {
fn lookup_album() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist_id = COLLECTION[1].meta.id.clone();
let artist_id = COLLECTION[1].id;
let album_id = COLLECTION[1].albums[0].meta.id.clone();
lookup_album_expectation(&mut mb_job_sender, &artist_id, &album_id);
@ -579,8 +592,8 @@ mod tests {
AppMachine::app_lookup_album(inner, fetch, &artist_id, &album_id, mbid());
}
fn search_artist_expectation(job_sender: &mut MockIMbJobSender, artist: &ArtistMeta) {
let requests = VecDeque::from([MbParams::search_artist(artist.clone())]);
fn search_artist_expectation(job_sender: &mut MockIMbJobSender, artist: ArtistMatching) {
let requests = VecDeque::from([MbParams::search_artist(artist)]);
job_sender
.expect_submit_background_job()
.with(predicate::always(), predicate::eq(requests))
@ -592,8 +605,10 @@ mod tests {
fn fetch_artist() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist = COLLECTION[3].meta.clone();
search_artist_expectation(&mut mb_job_sender, &artist);
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
search_artist_expectation(&mut mb_job_sender, matching);
let music_hoard = music_hoard(COLLECTION.to_owned());
let inner = AppInner::new(music_hoard, mb_job_sender);
@ -608,8 +623,8 @@ mod tests {
assert!(matches!(app, AppState::Fetch(_)));
}
fn lookup_artist_expectation(job_sender: &mut MockIMbJobSender, artist: &ArtistMeta) {
let requests = VecDeque::from([MbParams::lookup_artist(artist.clone(), mbid())]);
fn lookup_artist_expectation(job_sender: &mut MockIMbJobSender, artist: ArtistMatching) {
let requests = VecDeque::from([MbParams::lookup_artist(artist, mbid())]);
job_sender
.expect_submit_foreground_job()
.with(predicate::always(), predicate::eq(requests))
@ -621,8 +636,10 @@ mod tests {
fn lookup_artist() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist = COLLECTION[3].meta.clone();
lookup_artist_expectation(&mut mb_job_sender, &artist);
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
lookup_artist_expectation(&mut mb_job_sender, matching.clone());
let music_hoard = music_hoard(COLLECTION.to_owned());
let inner = AppInner::new(music_hoard, mb_job_sender);
@ -630,7 +647,7 @@ mod tests {
let (_fetch_tx, fetch_rx) = mpsc::channel();
let fetch = FetchState::search(fetch_rx);
AppMachine::app_lookup_artist(inner, fetch, &artist, mbid());
AppMachine::app_lookup_artist(inner, fetch, matching, mbid());
}
#[test]
@ -671,7 +688,9 @@ mod tests {
.expect_submit_foreground_job()
.return_once(|_, _| Err(DaemonError::JobChannelDisconnected));
let artist = COLLECTION[3].meta.clone();
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
let music_hoard = music_hoard(COLLECTION.to_owned());
let inner = AppInner::new(music_hoard, mb_job_sender);
@ -679,7 +698,7 @@ mod tests {
let (_fetch_tx, fetch_rx) = mpsc::channel();
let fetch = FetchState::search(fetch_rx);
let app = AppMachine::app_lookup_artist(inner, fetch, &artist, mbid());
let app = AppMachine::app_lookup_artist(inner, fetch, matching, mbid());
assert!(matches!(app, AppState::Error(_)));
}
@ -687,10 +706,12 @@ mod tests {
fn recv_ok_match_ok() {
let (tx, rx) = mpsc::channel::<MbApiResult>();
let artist = COLLECTION[3].meta.clone();
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
let artist_match = Entity::with_score(COLLECTION[2].meta.clone(), 80);
let artist_match_info =
EntityMatches::artist_search(artist.clone(), vec![artist_match.clone()]);
EntityMatches::artist_search(matching.clone(), vec![artist_match.clone()]);
let fetch_result = Ok(MbReturn::Match(artist_match_info));
tx.send(fetch_result).unwrap();
@ -706,7 +727,7 @@ mod tests {
MatchOption::CannotHaveMbid,
MatchOption::ManualInputMbid,
];
let expected = EntityMatches::artist_search(artist, match_options);
let expected = EntityMatches::artist_search(matching, match_options);
assert_eq!(match_state.matches, &expected);
}
@ -730,7 +751,7 @@ mod tests {
let (tx, rx) = mpsc::channel::<MbApiResult>();
let fetch = FetchState::fetch(rx);
let artist_id = collection[0].meta.id.clone();
let artist_id = collection[0].id;
let old_album = collection[0].albums[0].meta.clone();
let new_album = AlbumMeta::new(AlbumId::new("some new album"));
@ -764,7 +785,7 @@ mod tests {
let (tx, rx) = mpsc::channel::<MbApiResult>();
let fetch = FetchState::fetch(rx);
let artist_id = collection[0].meta.id.clone();
let artist_id = collection[0].id;
let old_album = collection[0].albums[0].meta.clone();
let new_album = AlbumMeta::new(AlbumId::new("some new album"));
@ -802,7 +823,7 @@ mod tests {
}
fn browse_release_group_expectation(artist: &Artist) -> MockIMbJobSender {
let requests = AppMachine::browse_release_group_job(&artist.meta.info.mb_ref);
let requests = AppMachine::browse_release_group_job(artist.id, &artist.meta.info.mb_ref);
let mut mb_job_sender = MockIMbJobSender::new();
mb_job_sender
.expect_submit_background_job()
@ -858,8 +879,10 @@ mod tests {
let app = AppMachine::app_fetch_next(inner, fetch);
assert!(matches!(app, AppState::Fetch(_)));
let artist = COLLECTION[3].meta.clone();
let match_info = EntityMatches::artist_search::<Entity<ArtistMeta>>(artist, vec![]);
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
let match_info = EntityMatches::artist_search::<Entity<ArtistMeta>>(matching, vec![]);
let fetch_result = Ok(MbReturn::Match(match_info));
tx.send(fetch_result).unwrap();

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

@ -173,11 +173,11 @@ impl AppMachine<MatchState> {
};
match self.state.current {
EntityMatches::Artist(artist_matches) => {
let matching = &artist_matches.matching;
let matching = artist_matches.matching;
AppMachine::app_lookup_artist(self.inner, self.state.fetch, matching, mbid)
}
EntityMatches::Album(album_matches) => {
let artist_id = &album_matches.artist;
let artist_id = &album_matches.artist_id;
let matching = &album_matches.matching;
AppMachine::app_lookup_album(
self.inner,
@ -215,7 +215,7 @@ impl AppMachine<MatchState> {
) -> Result<(), musichoard::Error> {
let coll = inner.music_hoard.get_collection();
let mut clashing = vec![];
if let Some(artist) = coll.iter().find(|artist| artist.meta.id == matches.artist) {
if let Some(artist) = coll.iter().find(|artist| artist.id == matches.artist_id) {
// While we expect only one, there is nothing stopping anybody from having multiple
// different albums with the same MBID.
let iter = artist.albums.iter();
@ -229,15 +229,15 @@ impl AppMachine<MatchState> {
let coll = inner.music_hoard.get_filtered();
let selection = KeySelection::get(coll, &inner.selection);
inner.music_hoard.remove_album(&matches.artist, &album)?;
inner.music_hoard.remove_album(&matches.artist_id, &album)?;
let coll = inner.music_hoard.get_filtered();
inner.selection.select_by_id(coll, selection);
}
let mh = &mut inner.music_hoard;
mh.merge_album_info(&matches.artist, &matches.matching, tuple.info)?;
mh.set_album_mb_ref(&matches.artist, &matches.matching, tuple.mb_ref)
mh.merge_album_info(&matches.artist_id, &matches.matching, tuple.info)?;
mh.set_album_mb_ref(&matches.artist_id, &matches.matching, tuple.mb_ref)
}
}
@ -285,11 +285,11 @@ impl IAppInteractMatch for AppMachine<MatchState> {
let inner = &mut self.inner;
let result = match self.state.current {
EntityMatches::Artist(ref mut matches) => match matches.list.extract_info(index) {
InfoOption::Info(tuple) => Self::select_artist(inner, matches, tuple),
InfoOption::Info(info) => Self::select_artist(inner, matches, info),
InfoOption::NeedInput => return self.get_input(),
},
EntityMatches::Album(ref mut matches) => match matches.list.extract_info(index) {
InfoOption::Info(tuple) => Self::select_album(inner, matches, tuple),
InfoOption::Info(info) => Self::select_album(inner, matches, info),
InfoOption::NeedInput => return self.get_input(),
},
};
@ -318,14 +318,14 @@ mod tests {
album::{
Album, AlbumDate, AlbumId, AlbumInfo, AlbumMeta, AlbumPrimaryType, AlbumSecondaryType,
},
artist::{Artist, ArtistId, ArtistMbRef, ArtistMeta},
artist::{Artist, ArtistId, ArtistMbRef, ArtistMeta, ArtistName},
Collection,
};
use crate::tui::{
app::{
machine::tests::{inner, inner_with_mb, input_event, music_hoard},
IApp, IAppAccess, IAppInput,
ArtistMatching, IApp, IAppAccess, IAppInput,
},
lib::{
interface::musicbrainz::{
@ -352,30 +352,41 @@ mod tests {
"00000000-0000-0000-0000-000000000000".try_into().unwrap()
}
fn artist_meta() -> ArtistMeta {
ArtistMeta::new(ArtistId::new("Artist")).with_mb_ref(ArtistMbRef::Some(mbid().into()))
fn artist_id() -> ArtistId {
ArtistId(1)
}
fn artist_name() -> ArtistName {
"Artist".into()
}
fn artist_meta<Name: Into<ArtistName>>(name: Name) -> ArtistMeta {
ArtistMeta::new(name).with_mb_ref(ArtistMbRef::Some(mbid().into()))
}
fn artist_match() -> EntityMatches {
let mut artist = artist_meta();
let id = artist_id();
let name = artist_name();
let meta = artist_meta(name.clone());
let artist_1 = artist.clone();
let artist_1 = meta.clone();
let artist_match_1 = Entity::with_score(artist_1, 100);
let artist_2 = artist.clone();
let artist_2 = meta.clone();
let mut artist_match_2 = Entity::with_score(artist_2, 100);
artist_match_2.disambiguation = Some(String::from("some disambiguation"));
artist.clear_mb_ref();
let list = vec![artist_match_1.clone(), artist_match_2.clone()];
EntityMatches::artist_search(artist, list)
EntityMatches::artist_search(ArtistMatching::new(id, name), list)
}
fn artist_lookup() -> EntityMatches {
let mut artist = artist_meta();
artist.clear_mb_ref();
let id = artist_id();
let name = artist_name();
let artist = artist_meta(name.clone());
let lookup = Entity::new(artist.clone());
EntityMatches::artist_lookup(artist, lookup)
EntityMatches::artist_lookup(ArtistMatching::new(id, name), lookup)
}
fn album_id() -> AlbumId {
@ -396,7 +407,7 @@ mod tests {
}
fn album_match() -> EntityMatches {
let artist_id = ArtistId::new("Artist");
let artist_id = ArtistId(1);
let mut album_id = album_id();
let album_meta = album_meta(album_id.clone());
@ -414,7 +425,7 @@ mod tests {
}
fn album_lookup() -> EntityMatches {
let artist_id = ArtistId::new("Artist");
let artist_id = ArtistId(1);
let mut album_id = album_id();
let album_meta = album_meta(album_id.clone());
@ -460,7 +471,7 @@ mod tests {
let collection = vec![];
let mut music_hoard = music_hoard(collection.clone());
let artist_id = ArtistId::new("Artist");
let artist_id = ArtistId(0);
match matches_info {
EntityMatches::Album(_) => {
let album_id = AlbumId::new("Album");
@ -572,11 +583,12 @@ mod tests {
match matches_info {
EntityMatches::Album(_) => panic!(),
EntityMatches::Artist(_) => {
let meta = artist_meta();
let id = artist_id();
let meta = artist_meta(artist_name());
music_hoard
.expect_merge_artist_info()
.with(eq(meta.id.clone()), eq(meta.info))
.with(eq(id), eq(meta.info))
.times(1)
.return_once(|_, _| Ok(()));
}
@ -596,7 +608,7 @@ mod tests {
let meta = album_meta(album_id.clone());
let mb_ref = album_id.mb_ref.clone();
album_id.clear_mb_ref();
let artist = matches.artist.clone();
let artist = matches.artist_id;
let mut seq = Sequence::new();
mh.expect_get_collection()
@ -650,7 +662,7 @@ mod tests {
// matching album_id.
// (1) Same artist as matches_info.
let mut artist = Artist::new(ArtistId::new("Artist"));
let mut artist = Artist::new(1, "Artist");
// (2) An album with the same album_id as the selected one.
artist.albums.push(Album::new(AlbumId::new("Album")));
@ -818,15 +830,15 @@ mod tests {
#[test]
fn select_manual_input_artist() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist = ArtistMeta::new(ArtistId::new("Artist"));
let requests = VecDeque::from([MbParams::lookup_artist(artist.clone(), mbid())]);
let matching = ArtistMatching::new(artist_id(), artist_name());
let requests = VecDeque::from([MbParams::lookup_artist(matching.clone(), mbid())]);
mb_job_sender
.expect_submit_foreground_job()
.with(predicate::always(), predicate::eq(requests))
.return_once(|_, _| Ok(()));
let matches_vec: Vec<Entity<ArtistMeta>> = vec![];
let artist_match = EntityMatches::artist_search(artist.clone(), matches_vec);
let artist_match = EntityMatches::artist_search(matching.clone(), matches_vec);
let matches = AppMachine::match_state(
inner_with_mb(music_hoard(vec![]), mb_job_sender),
match_state(artist_match),
@ -846,7 +858,7 @@ mod tests {
#[test]
fn select_manual_input_album() {
let mut mb_job_sender = MockIMbJobSender::new();
let artist_id = ArtistId::new("Artist");
let artist_id = artist_id();
let album = AlbumMeta::new("Album").with_date(1990);
let requests = VecDeque::from([MbParams::lookup_release_group(
artist_id.clone(),

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

@ -225,7 +225,10 @@ mod tests {
};
use crate::tui::{
app::{AppState, EntityMatches, IApp, IAppInput, IAppInteractBrowse, InputEvent},
app::{
AppState, ArtistMatching, EntityMatches, IApp, IAppInput, IAppInteractBrowse,
InputEvent,
},
lib::{
interface::musicbrainz::{api::Entity, daemon::MockIMbJobSender},
MockIMusicHoard,
@ -519,8 +522,13 @@ mod tests {
let (_, rx) = mpsc::channel();
let fetch = FetchState::search(rx);
let artist = ArtistMeta::new(ArtistId::new("Artist"));
let info = EntityMatches::artist_lookup(artist.clone(), Entity::new(artist.clone()));
let id = ArtistId(1);
let name = String::from("Artist");
let meta = ArtistMeta::new(name.clone());
let matching = ArtistMatching::new(id, name);
let info = EntityMatches::artist_lookup(matching, Entity::new(meta));
app =
AppMachine::match_state(app.unwrap_browse().inner, MatchState::new(info, fetch)).into();

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

@ -159,10 +159,10 @@ impl IAppInteractSearchPrivate for AppMachine<SearchState> {
}
fn predicate_artists(case_sens: bool, char_sens: bool, search: &str, probe: &Artist) -> bool {
let name = string::normalize_string_with(&probe.meta.id.name, !case_sens, !char_sens);
let name = string::normalize_string_with(&probe.meta.name, !case_sens, !char_sens);
let mut result = name.string.starts_with(search);
if let Some(ref probe_sort) = probe.meta.info.sort {
if let Some(ref probe_sort) = probe.meta.sort {
if !result {
let name = string::normalize_string_with(probe_sort, !case_sens, !char_sens);
result = name.string.starts_with(search);

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

@ -7,7 +7,7 @@ pub use selection::{Category, Selection};
use musichoard::collection::{
album::{AlbumId, AlbumMeta},
artist::{ArtistId, ArtistMeta},
artist::{ArtistId, ArtistMeta, ArtistName},
Collection,
};
@ -228,13 +228,28 @@ impl<T> From<Entity<T>> for MatchOption<T> {
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ArtistMatches {
pub matching: ArtistMeta,
pub matching: ArtistMatching,
pub list: Vec<MatchOption<ArtistMeta>>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ArtistMatching {
pub id: ArtistId,
pub name: ArtistName,
}
impl ArtistMatching {
pub fn new<Name: Into<ArtistName>>(id: ArtistId, name: Name) -> Self {
ArtistMatching {
id,
name: name.into(),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AlbumMatches {
pub artist: ArtistId,
pub artist_id: ArtistId,
pub matching: AlbumId,
pub list: Vec<MatchOption<AlbumMeta>>,
}
@ -246,40 +261,43 @@ pub enum EntityMatches {
}
impl EntityMatches {
pub fn artist_search<M: Into<MatchOption<ArtistMeta>>>(
matching: ArtistMeta,
list: Vec<M>,
) -> Self {
pub fn artist_search<M>(matching: ArtistMatching, list: Vec<M>) -> Self
where
M: Into<MatchOption<ArtistMeta>>,
{
let list = list.into_iter().map(Into::into).collect();
EntityMatches::Artist(ArtistMatches { matching, list })
}
pub fn album_search<M: Into<MatchOption<AlbumMeta>>>(
artist: ArtistId,
artist_id: ArtistId,
matching: AlbumId,
list: Vec<M>,
) -> Self {
let list = list.into_iter().map(Into::into).collect();
EntityMatches::Album(AlbumMatches {
artist,
artist_id,
matching,
list,
})
}
pub fn artist_lookup<M: Into<MatchOption<ArtistMeta>>>(matching: ArtistMeta, item: M) -> Self {
pub fn artist_lookup<M>(matching: ArtistMatching, item: M) -> Self
where
M: Into<MatchOption<ArtistMeta>>,
{
let list = vec![item.into()];
EntityMatches::Artist(ArtistMatches { matching, list })
}
pub fn album_lookup<M: Into<MatchOption<AlbumMeta>>>(
artist: ArtistId,
artist_id: ArtistId,
matching: AlbumId,
item: M,
) -> Self {
let list = vec![item.into()];
EntityMatches::Album(AlbumMatches {
artist,
artist_id,
matching,
list,
})

10
src/tui/app/selection/artist.rs
View File

@ -1,10 +1,6 @@
use std::cmp;
use musichoard::collection::{
album::Album,
artist::{Artist, ArtistId},
track::Track,
};
use musichoard::collection::{album::Album, artist::Artist, track::Track};
use crate::tui::app::{
selection::{
@ -198,7 +194,7 @@ impl ArtistSelection {
}
pub struct KeySelectArtist {
key: (ArtistId,),
key: (String,),
album: Option<KeySelectAlbum>,
}
@ -215,7 +211,7 @@ impl KeySelectArtist {
}
pub fn get_sort_key(&self) -> (&str,) {
(&self.key.0.name,)
(&self.key.0,)
}
}

25
src/tui/lib/external/musicbrainz/api/mod.rs
View File

@ -5,7 +5,7 @@ use std::collections::HashMap;
use musichoard::{
collection::{
album::{AlbumDate, AlbumId, AlbumInfo, AlbumLibId, AlbumMbRef, AlbumMeta, AlbumSeq},
artist::{ArtistId, ArtistInfo, ArtistMbRef, ArtistMeta},
artist::{ArtistInfo, ArtistMbRef, ArtistMeta, ArtistName},
musicbrainz::Mbid,
},
external::musicbrainz::{
@ -55,8 +55,8 @@ impl<Http: IMusicBrainzHttp> IMusicBrainz for MusicBrainz<Http> {
Ok(from_lookup_release_group_response(mb_response))
}
fn search_artist(&mut self, artist: &ArtistMeta) -> Result<Vec<Entity<ArtistMeta>>, Error> {
let query = SearchArtistRequest::new().string(&artist.id.name);
fn search_artist(&mut self, name: &ArtistName) -> Result<Vec<Entity<ArtistMeta>>, Error> {
let query = SearchArtistRequest::new().string(name);
let paging = PageSettings::default();
let mb_response = self.client.search_artist(&query, &paging)?;
@ -70,19 +70,19 @@ impl<Http: IMusicBrainzHttp> IMusicBrainz for MusicBrainz<Http> {
fn search_release_group(
&mut self,
arid: &Mbid,
album: &AlbumMeta,
artist_mbid: &Mbid,
meta: &AlbumMeta,
) -> Result<Vec<Entity<AlbumMeta>>, Error> {
// Some release groups may have a promotional early release messing up the search. Searching
// with just the year should be enough anyway.
let date = AlbumDate::new(album.info.date.year, None, None);
let date = AlbumDate::new(meta.info.date.year, None, None);
let query = SearchReleaseGroupRequest::new()
.arid(arid)
.arid(artist_mbid)
.and()
.first_release_date(&date)
.and()
.release_group(&album.id.title);
.release_group(&meta.id.title);
let paging = PageSettings::default();
let mb_response = self.client.search_release_group(&query, &paging)?;
@ -96,10 +96,11 @@ impl<Http: IMusicBrainzHttp> IMusicBrainz for MusicBrainz<Http> {
fn browse_release_group(
&mut self,
artist: &Mbid,
artist_mbid: &Mbid,
paging: &mut Option<PageSettings>,
) -> Result<Vec<Entity<AlbumMeta>>, Error> {
let request = BrowseReleaseGroupRequest::artist(artist).filter_status_website_default();
let request =
BrowseReleaseGroupRequest::artist(artist_mbid).filter_status_website_default();
let page = paging.take().unwrap_or_default();
let mb_response = self.client.browse_release_group(&request, &page)?;
@ -115,11 +116,9 @@ fn from_mb_artist_meta(meta: MbArtistMeta) -> (ArtistMeta, Option<String>) {
let sort = Some(meta.sort_name).filter(|s| s != &meta.name);
(
ArtistMeta {
id: ArtistId {
name: meta.name,
},
info: ArtistInfo {
sort,
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(meta.id.into()),
properties: HashMap::new(),
},

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

@ -256,30 +256,26 @@ impl JobInstance {
MbParams::Lookup(lookup) => match lookup {
LookupParams::Artist(p) => musicbrainz
.lookup_artist(&p.mbid)
.map(|rv| EntityMatches::artist_lookup(p.artist.clone(), rv)),
LookupParams::ReleaseGroup(p) => {
musicbrainz.lookup_release_group(&p.mbid).map(|rv| {
EntityMatches::album_lookup(p.artist_id.clone(), p.album_id.clone(), rv)
})
}
.map(|rv| EntityMatches::artist_lookup(p.matching.clone(), rv)),
LookupParams::ReleaseGroup(p) => musicbrainz
.lookup_release_group(&p.mbid)
.map(|rv| EntityMatches::album_lookup(p.artist_id, p.id.clone(), rv)),
}
.map(MbReturn::Match),
MbParams::Search(search) => match search {
SearchParams::Artist(p) => musicbrainz
.search_artist(&p.artist)
.map(|rv| EntityMatches::artist_search(p.artist.clone(), rv)),
.search_artist(&p.matching.name)
.map(|rv| EntityMatches::artist_search(p.matching.clone(), rv)),
SearchParams::ReleaseGroup(p) => musicbrainz
.search_release_group(&p.artist_mbid, &p.album)
.map(|rv| {
EntityMatches::album_search(p.artist_id.clone(), p.album.id.clone(), rv)
}),
.search_release_group(&p.artist_mbid, &p.meta)
.map(|rv| EntityMatches::album_search(p.artist_id, p.meta.id.clone(), rv)),
}
.map(MbReturn::Match),
MbParams::Browse(browse) => match browse {
BrowseParams::ReleaseGroup(params) => {
Self::init_paging_if_none(paging);
musicbrainz
.browse_release_group(&params.artist, paging)
.browse_release_group(&params.artist_mbid, paging)
.map(|rv| EntityList::Album(rv.into_iter().map(|rg| rg.entity).collect()))
}
}
@ -350,11 +346,12 @@ mod tests {
use mockall::{predicate, Sequence};
use musichoard::collection::{
album::AlbumMeta,
artist::{ArtistId, ArtistMeta},
artist::{ArtistId, ArtistMeta, ArtistName},
musicbrainz::{IMusicBrainzRef, MbRefOption, Mbid},
};
use crate::tui::{
app::ArtistMatching,
event::{Event, EventError, MockIFetchCompleteEventSender},
lib::interface::musicbrainz::api::{Entity, MockIMusicBrainz},
testmod::COLLECTION,
@ -426,38 +423,43 @@ mod tests {
}
fn lookup_artist_requests() -> VecDeque<MbParams> {
let artist = COLLECTION[3].meta.clone();
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
let mbid = mbid();
VecDeque::from([MbParams::lookup_artist(artist, mbid)])
VecDeque::from([MbParams::lookup_artist(matching, mbid)])
}
fn lookup_release_group_requests() -> VecDeque<MbParams> {
let artist_id = COLLECTION[1].meta.id.clone();
let artist_id = COLLECTION[1].id;
let album_id = COLLECTION[1].albums[0].meta.id.clone();
let mbid = mbid();
VecDeque::from([MbParams::lookup_release_group(artist_id, album_id, mbid)])
}
fn search_artist_requests() -> VecDeque<MbParams> {
let artist = COLLECTION[3].meta.clone();
VecDeque::from([MbParams::search_artist(artist)])
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let matching = ArtistMatching::new(id, name);
VecDeque::from([MbParams::search_artist(matching)])
}
fn search_artist_expectations() -> (ArtistMeta, Vec<Entity<ArtistMeta>>) {
let artist = COLLECTION[3].meta.clone();
fn search_artist_expectations() -> (ArtistName, Vec<Entity<ArtistMeta>>) {
let name = COLLECTION[3].meta.name.clone();
let meta = COLLECTION[3].meta.clone();
let artist_match_1 = Entity::with_score(artist.clone(), 100);
let artist_match_2 = Entity::with_score(artist.clone(), 50);
let artist_match_1 = Entity::with_score(meta.clone(), 100);
let artist_match_2 = Entity::with_score(meta.clone(), 50);
let matches = vec![artist_match_1.clone(), artist_match_2.clone()];
(artist, matches)
(name, matches)
}
fn search_albums_requests() -> VecDeque<MbParams> {
let mbref = mb_ref_opt_as_ref(&COLLECTION[1].meta.info.mb_ref);
let arid = mb_ref_opt_unwrap(mbref).mbid().clone();
let artist_id = COLLECTION[1].meta.id.clone();
let artist_id = COLLECTION[1].id;
let album_1 = COLLECTION[1].albums[0].meta.clone();
let album_4 = COLLECTION[1].albums[3].meta.clone();
@ -470,11 +472,15 @@ mod tests {
fn browse_albums_requests() -> VecDeque<MbParams> {
let mbref = mb_ref_opt_as_ref(&COLLECTION[1].meta.info.mb_ref);
let arid = mb_ref_opt_unwrap(mbref).mbid().clone();
VecDeque::from([MbParams::browse_release_group(arid)])
VecDeque::from([MbParams::browse_release_group(album_artist_id(), arid)])
}
fn artist_id() -> ArtistId {
ArtistId(1)
}
fn album_artist_id() -> ArtistId {
COLLECTION[1].meta.id.clone()
COLLECTION[1].id
}
fn album_arid_expectation() -> Mbid {
@ -594,8 +600,12 @@ mod tests {
fn execute_lookup_artist() {
let mut musicbrainz = musicbrainz();
let mbid = mbid();
let artist = COLLECTION[3].meta.clone();
let lookup = Entity::new(artist.clone());
let id = COLLECTION[3].id;
let name = COLLECTION[3].meta.name.clone();
let meta = COLLECTION[3].meta.clone();
let matching = ArtistMatching::new(id, name);
let lookup = Entity::new(meta.clone());
lookup_artist_expectation(&mut musicbrainz, &mbid, &lookup);
let mut event_sender = event_sender();
@ -622,7 +632,7 @@ mod tests {
assert_eq!(
result,
Ok(MbReturn::Match(EntityMatches::artist_lookup(
artist, lookup
matching, lookup
)))
);
}
@ -681,13 +691,13 @@ mod tests {
fn search_artist_expectation(
musicbrainz: &mut MockIMusicBrainz,
artist: &ArtistMeta,
name: &ArtistName,
matches: &[Entity<ArtistMeta>],
) {
let result = Ok(matches.to_owned());
musicbrainz
.expect_search_artist()
.with(predicate::eq(artist.clone()))
.with(predicate::eq(name.clone()))
.times(1)
.return_once(|_| result);
}
@ -695,8 +705,9 @@ mod tests {
#[test]
fn execute_search_artist() {
let mut musicbrainz = musicbrainz();
let (artist, matches) = search_artist_expectations();
search_artist_expectation(&mut musicbrainz, &artist, &matches);
let id = artist_id();
let (name, matches) = search_artist_expectations();
search_artist_expectation(&mut musicbrainz, &name, &matches);
let mut event_sender = event_sender();
fetch_complete_expectation(&mut event_sender, 1);
@ -719,10 +730,11 @@ mod tests {
assert_eq!(result, Err(JobError::JobQueueEmpty));
let result = result_receiver.try_recv().unwrap();
let matching = ArtistMatching::new(id, name);
assert_eq!(
result,
Ok(MbReturn::Match(EntityMatches::artist_search(
artist, matches
matching, matches
)))
);
}

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

@ -4,7 +4,11 @@
use mockall::automock;
use musichoard::{
collection::{album::AlbumMeta, artist::ArtistMeta, musicbrainz::Mbid},
collection::{
album::AlbumMeta,
artist::{ArtistMeta, ArtistName},
musicbrainz::Mbid,
},
external::musicbrainz::api::PageSettings,
};
@ -12,15 +16,16 @@ use musichoard::{
pub trait IMusicBrainz {
fn lookup_artist(&mut self, mbid: &Mbid) -> Result<Entity<ArtistMeta>, Error>;
fn lookup_release_group(&mut self, mbid: &Mbid) -> Result<Entity<AlbumMeta>, Error>;
fn search_artist(&mut self, artist: &ArtistMeta) -> Result<Vec<Entity<ArtistMeta>>, Error>;
fn search_artist(&mut self, name: &ArtistName) -> Result<Vec<Entity<ArtistMeta>>, Error>;
// TODO: AlbumMeta -> AlbumTitle
fn search_release_group(
&mut self,
arid: &Mbid,
album: &AlbumMeta,
artist_mbid: &Mbid,
meta: &AlbumMeta,
) -> Result<Vec<Entity<AlbumMeta>>, Error>;
fn browse_release_group(
&mut self,
artist: &Mbid,
artist_mbid: &Mbid,
paging: &mut Option<PageSettings>,
) -> Result<Vec<Entity<AlbumMeta>>, Error>;
}

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

@ -2,11 +2,14 @@ use std::{collections::VecDeque, fmt, sync::mpsc};
use musichoard::collection::{
album::{AlbumId, AlbumMeta},
artist::{ArtistId, ArtistMeta},
artist::ArtistId,
musicbrainz::Mbid,
};
use crate::tui::{app::EntityMatches, lib::interface::musicbrainz::api::Error as MbApiError};
use crate::tui::{
app::{ArtistMatching, EntityMatches},
lib::interface::musicbrainz::api::Error as MbApiError,
};
#[cfg(test)]
use mockall::automock;
@ -74,14 +77,14 @@ pub enum LookupParams {
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LookupArtistParams {
pub artist: ArtistMeta,
pub matching: ArtistMatching,
pub mbid: Mbid,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LookupReleaseGroupParams {
pub artist_id: ArtistId,
pub album_id: AlbumId,
pub id: AlbumId,
pub mbid: Mbid,
}
@ -93,14 +96,15 @@ pub enum SearchParams {
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SearchArtistParams {
pub artist: ArtistMeta,
pub matching: ArtistMatching,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SearchReleaseGroupParams {
pub artist_id: ArtistId,
pub artist_mbid: Mbid,
pub album: AlbumMeta,
// TODO: probably needs AlbumId when we get there
pub meta: AlbumMeta,
}
#[derive(Clone, Debug, PartialEq, Eq)]
@ -110,37 +114,39 @@ pub enum BrowseParams {
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BrowseReleaseGroupParams {
pub artist: Mbid,
pub artist_id: ArtistId,
pub artist_mbid: Mbid,
}
impl MbParams {
pub fn lookup_artist(artist: ArtistMeta, mbid: Mbid) -> Self {
MbParams::Lookup(LookupParams::Artist(LookupArtistParams { artist, mbid }))
pub fn lookup_artist(matching: ArtistMatching, mbid: Mbid) -> Self {
MbParams::Lookup(LookupParams::Artist(LookupArtistParams { matching, mbid }))
}
pub fn lookup_release_group(artist_id: ArtistId, album_id: AlbumId, mbid: Mbid) -> Self {
pub fn lookup_release_group(artist_id: ArtistId, id: AlbumId, mbid: Mbid) -> Self {
MbParams::Lookup(LookupParams::ReleaseGroup(LookupReleaseGroupParams {
artist_id,
album_id,
id,
mbid,
}))
}
pub fn search_artist(artist: ArtistMeta) -> Self {
MbParams::Search(SearchParams::Artist(SearchArtistParams { artist }))
pub fn search_artist(matching: ArtistMatching) -> Self {
MbParams::Search(SearchParams::Artist(SearchArtistParams { matching }))
}
pub fn search_release_group(artist_id: ArtistId, artist_mbid: Mbid, album: AlbumMeta) -> Self {
pub fn search_release_group(artist_id: ArtistId, artist_mbid: Mbid, meta: AlbumMeta) -> Self {
MbParams::Search(SearchParams::ReleaseGroup(SearchReleaseGroupParams {
artist_id,
artist_mbid,
album,
meta,
}))
}
pub fn browse_release_group(artist: Mbid) -> Self {
pub fn browse_release_group(artist_id: ArtistId, artist_mbid: Mbid) -> Self {
MbParams::Browse(BrowseParams::ReleaseGroup(BrowseReleaseGroupParams {
artist,
artist_id,
artist_mbid,
}))
}
}

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

@ -126,7 +126,7 @@ impl<'a, 'b> ArtistState<'a, 'b> {
let list = List::new(
artists
.iter()
.map(|a| ListItem::new(a.meta.id.name.as_str()))
.map(|a| ListItem::new(a.meta.name.as_str()))
.collect::<Vec<ListItem>>(),
);

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

@ -3,7 +3,7 @@ use musichoard::collection::{
AlbumDate, AlbumId, AlbumLibId, AlbumMeta, AlbumOwnership, AlbumPrimaryType,
AlbumSecondaryType, AlbumSeq,
},
artist::ArtistMeta,
artist::{ArtistMeta, ArtistName},
musicbrainz::{IMusicBrainzRef, MbRefOption},
track::{TrackFormat, TrackQuality},
};
@ -118,8 +118,8 @@ impl UiDisplay {
}
}
pub fn display_artist_matching(artist: &ArtistMeta) -> String {
format!("Matching artist: {}", &artist.id.name)
pub fn display_artist_matching(name: &ArtistName) -> String {
format!("Matching artist: {}", name)
}
pub fn display_album_matching(album: &AlbumId) -> String {
@ -128,7 +128,7 @@ impl UiDisplay {
pub fn display_matching_info(info: &EntityMatches) -> String {
match info {
EntityMatches::Artist(m) => UiDisplay::display_artist_matching(&m.matching),
EntityMatches::Artist(m) => UiDisplay::display_artist_matching(&m.matching.name),
EntityMatches::Album(m) => UiDisplay::display_album_matching(&m.matching),
}
}
@ -159,7 +159,7 @@ impl UiDisplay {
fn display_option_artist(artist: &ArtistMeta, disambiguation: &Option<String>) -> String {
format!(
"{}{}",
artist.id.name,
artist.name,
disambiguation
.as_ref()
.filter(|s| !s.is_empty())

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

@ -74,7 +74,7 @@ impl<'a> ArtistOverlay<'a> {
"Artist: {}\n\n{item_indent}\
MusicBrainz: {}\n{item_indent}\
Properties: {}",
artist.map(|a| a.meta.id.name.as_str()).unwrap_or(""),
artist.map(|a| a.meta.name.as_str()).unwrap_or(""),
artist
.map(|a| UiDisplay::display_mb_ref_option_as_url(&a.meta.info.mb_ref))
.unwrap_or_default(),

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

@ -1,6 +1,6 @@
use musichoard::collection::{
album::{AlbumId, AlbumMeta},
artist::ArtistMeta,
artist::{ArtistMeta, ArtistName},
};
use ratatui::widgets::{List, ListItem};
@ -18,13 +18,13 @@ pub struct MatchOverlay<'a, 'b> {
impl<'a, 'b> MatchOverlay<'a, 'b> {
pub fn new(info: &'a EntityMatches, state: &'b mut WidgetState) -> Self {
match info {
EntityMatches::Artist(m) => Self::artists(&m.matching, &m.list, state),
EntityMatches::Artist(m) => Self::artists(&m.matching.name, &m.list, state),
EntityMatches::Album(m) => Self::albums(&m.matching, &m.list, state),
}
}
fn artists(
matching: &ArtistMeta,
matching: &ArtistName,
matches: &'a [MatchOption<ArtistMeta>],
state: &'b mut WidgetState,
) -> Self {

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

@ -200,11 +200,11 @@ impl IUi for Ui {
mod tests {
use musichoard::collection::{
album::{AlbumDate, AlbumId, AlbumInfo, AlbumMeta, AlbumPrimaryType, AlbumSecondaryType},
artist::{Artist, ArtistId, ArtistMeta},
artist::{Artist, ArtistId, ArtistMeta, ArtistName},
};
use crate::tui::{
app::{AppPublic, AppPublicInner, Delta, MatchStatePublic},
app::{AppPublic, AppPublicInner, ArtistMatching, Delta, MatchStatePublic},
lib::interface::musicbrainz::api::Entity,
testmod::COLLECTION,
tests::terminal,
@ -287,7 +287,7 @@ mod tests {
#[test]
fn empty_album() {
let mut artists: Vec<Artist> = vec![Artist::new(ArtistId::new("An artist"))];
let mut artists: Vec<Artist> = vec![Artist::new(0, "An artist")];
artists[0].albums.push(Album::new("An album"));
let mut selection = Selection::new(&artists);
@ -324,33 +324,49 @@ mod tests {
draw_test_suite(artists, &mut selection);
}
fn artist_meta() -> ArtistMeta {
ArtistMeta::new(ArtistId::new("an artist"))
fn artist_id() -> ArtistId {
ArtistId(1)
}
fn artist_name() -> ArtistName {
"an artist".into()
}
fn artist_meta<Name: Into<ArtistName>>(name: Name) -> ArtistMeta {
ArtistMeta::new(name)
}
fn artist_matches() -> EntityMatches {
let artist = artist_meta();
let artist_match = Entity::with_score(artist.clone(), 80);
let id = artist_id();
let name = artist_name();
let meta = artist_meta(name.clone());
let matching = ArtistMatching::new(id, name);
let artist_match = Entity::with_score(meta, 80);
let list = vec![artist_match.clone(), artist_match.clone()];
let mut info = EntityMatches::artist_search(artist, list);
let mut info = EntityMatches::artist_search(matching, list);
info.push_cannot_have_mbid();
info.push_manual_input_mbid();
info
}
fn artist_lookup() -> EntityMatches {
let artist = artist_meta();
let artist_lookup = Entity::new(artist.clone());
let id = artist_id();
let name = artist_name();
let meta = artist_meta(name.clone());
let matching = ArtistMatching::new(id, name);
let mut info = EntityMatches::artist_lookup(artist, artist_lookup);
let artist_lookup = Entity::new(meta.clone());
let mut info = EntityMatches::artist_lookup(matching, artist_lookup);
info.push_cannot_have_mbid();
info.push_manual_input_mbid();
info
}
fn album_artist_id() -> ArtistId {
ArtistId::new("Artist")
ArtistId(1)
}
fn album_id() -> AlbumId {

25
tests/testlib.rs
View File

@ -15,12 +15,11 @@ use musichoard::collection::{
pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| -> Collection {
vec![
Artist {
id: ArtistId(1),
meta: ArtistMeta {
id: ArtistId {
name: String::from("Аркона"),
},
info: ArtistInfo {
sort: Some(String::from("Arkona")),
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/baad262d-55ef-427a-83c7-f7530964f212"
).unwrap()),
@ -207,12 +206,11 @@ pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| -> Collection {
}],
},
Artist {
id: ArtistId(2),
meta: ArtistMeta {
id: ArtistId {
name: String::from("Eluveitie"),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/8000598a-5edb-401c-8e6d-36b167feaf38"
).unwrap()),
@ -456,12 +454,11 @@ pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| -> Collection {
],
},
Artist {
id: ArtistId(3),
meta: ArtistMeta {
id: ArtistId {
name: String::from("Frontside"),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/3a901353-fccd-4afd-ad01-9c03f451b490"
).unwrap()),
@ -612,12 +609,11 @@ pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| -> Collection {
}],
},
Artist {
id: ArtistId(4),
meta: ArtistMeta {
id: ArtistId {
name: String::from("Heaven’s Basement"),
},
info: ArtistInfo {
sort: Some(String::from("Heaven’s Basement")),
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/c2c4d56a-d599-4a18-bd2f-ae644e2198cc"
).unwrap()),
@ -746,12 +742,11 @@ pub static COLLECTION: Lazy<Vec<Artist>> = Lazy::new(|| -> Collection {
}],
},
Artist {
id: ArtistId(5),
meta: ArtistMeta {
id: ArtistId {
name: String::from("Metallica"),
},
info: ArtistInfo {
sort: None,
info: ArtistInfo {
mb_ref: ArtistMbRef::Some(MbArtistRef::from_url_str(
"https://musicbrainz.org/artist/65f4f0c5-ef9e-490c-aee3-909e7ae6b2ab"
).unwrap()),