feat(coverart): coverart builder to make specific queries to coverart api

examples/fetch_release_coverart.rs

@@ -1,6 +1,7 @@
 extern crate musicbrainz_rs;
 
 use musicbrainz_rs::entity::release::*;
+use musicbrainz_rs::entity::CoverartResponse;
 use musicbrainz_rs::prelude::*;
 use musicbrainz_rs::FetchCoverart;
 
@@ -10,8 +11,12 @@ fn main() {
         .execute()
         .expect("Unable to get cover art");
 
-    assert_eq!(in_utero_coverart.images[0].front, true);
-    assert_eq!(in_utero_coverart.images[0].back, false);
+    if let CoverartResponse::Json(coverart) = in_utero_coverart {
+        println!("{}", coverart.images[0].back);
+        println!("{}", coverart.images[0].image);
+    }
+
+    println!("");
 
     let in_utero = Release::fetch()
         .id("76df3287-6cda-33eb-8e9a-044b5e15ffdd")
@@ -23,6 +28,21 @@ fn main() {
         .execute()
         .expect("Unable to get coverart");
 
-    assert_eq!(in_utero_coverart.images[0].front, true);
-    assert_eq!(in_utero_coverart.images[0].back, false);
+    if let CoverartResponse::Json(coverart) = in_utero_coverart {
+        println!("{}", coverart.images[0].back);
+        println!("{}", coverart.images[0].image);
+    }
+
+    println!("");
+
+    let in_utero_500px_front_coverart = Release::fetch_coverart()
+        .id("76df3287-6cda-33eb-8e9a-044b5e15ffdd")
+        .res_500()
+        .back()
+        .execute()
+        .expect("Unable to get cover art");
+
+    if let CoverartResponse::Url(coverart_url) = in_utero_500px_front_coverart {
+        println!("{}", coverart_url);
+    }
 }

src/entity/mod.rs

@@ -3,6 +3,7 @@ use std::marker::PhantomData;
 use crate::config::*;
 use crate::entity::area::Area;
 use crate::entity::artist::Artist;
+use crate::entity::coverart::Coverart;
 use crate::entity::event::Event;
 use crate::entity::instrument::*;
 use crate::entity::label::Label;
@@ -15,9 +16,8 @@ use crate::entity::url::Url;
 use crate::entity::work::Work;
 use crate::Fetch;
 use crate::Path;
-use crate::Query;
 use crate::{Browse, Search};
-use crate::{FetchCoverart, FetchCoverartQuery};
+use crate::{CoverartQuery, FetchCoverart, FetchCoverartQuery};
 
 macro_rules! impl_includes {
     ($ty: ty, $(($args:ident, $inc: expr)),+) => {
@@ -63,10 +63,13 @@ macro_rules! impl_fetchcoverart {
     ($($t: ty), +) => {
         $(impl<'a> FetchCoverart<'a> for $t {
             fn get_coverart(&self) -> FetchCoverartQuery<Self> {
-                let mut coverart_query = FetchCoverartQuery(Query {
+                let mut coverart_query = FetchCoverartQuery(CoverartQuery {
                     path: format!("{}/{}", BASE_COVERART_URL, Self::path()),
                     phantom: PhantomData,
-                    include: vec![],
+                    target: CoverartTarget {
+                        img_type: None,
+                        img_res: None,
+                    },
                 });
                 coverart_query.id(&self.id);
                 coverart_query
@@ -371,3 +374,47 @@ impl Browsable for Instrument {
     const OFFSET_FIELD: &'static str = "instrument-offset";
     const ENTITIES_FIELD: &'static str = "instruments";
 }
+
+#[derive(Clone, Debug)]
+pub struct CoverartTarget {
+    pub img_type: Option<CoverartType>,
+    pub img_res: Option<CoverartResolution>,
+}
+
+#[derive(Clone, Debug)]
+pub enum CoverartResponse {
+    Json(Coverart),
+    Url(String),
+}
+
+#[derive(Clone, Debug)]
+pub enum CoverartType {
+    Front,
+    Back,
+}
+
+impl CoverartType {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            CoverartType::Front => "front",
+            CoverartType::Back => "back",
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum CoverartResolution {
+    Res250,
+    Res500,
+    Res1200,
+}
+
+impl CoverartResolution {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            CoverartResolution::Res250 => "250",
+            CoverartResolution::Res500 => "500",
+            CoverartResolution::Res1200 => "1200",
+        }
+    }
+}

src/lib.rs

@@ -50,12 +50,12 @@ pub mod entity;
 /// Brings trait and type needed to perform any API query in scope
 pub mod prelude;
 
-use crate::entity::coverart::Coverart;
 use crate::entity::search::{SearchResult, Searchable};
 use deserialization::date_format;
 use entity::Browsable;
 use entity::BrowseResult;
 use entity::Include;
+use entity::{CoverartResolution, CoverartResponse, CoverartTarget, CoverartType};
 
 /// Type alias for [reqwest::Error]
 pub type Error = reqwest::Error;
@@ -100,16 +100,28 @@ pub struct FetchQuery<T>(Query<T>);
 /// # use musicbrainz_rs::prelude::*;
 /// # fn main() -> Result<(), Error> {
 /// # use musicbrainz_rs::entity::release::Release;
+/// # use musicbrainz_rs::entity::CoverartResponse;
 /// let in_utero_coverart = Release::fetch_coverart()
 ///         .id("76df3287-6cda-33eb-8e9a-044b5e15ffdd")
-///         .execute();
-///
-/// assert!(in_utero_coverart?.images[0].front, true);
+///         .execute()?;
+/// if let CoverartResponse::Json(coverart) = in_utero_coverart {
+///     assert_eq!(coverart.images[0].front, true);
+///     assert_eq!(coverart.images[0].back, false);
+/// } else {
+///     assert!(false);
+/// }
 /// #   Ok(())
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct FetchCoverartQuery<T>(Query<T>);
+struct CoverartQuery<T> {
+    path: String,
+    target: CoverartTarget,
+    phantom: PhantomData<T>,
+}
+
+#[derive(Clone, Debug)]
+pub struct FetchCoverartQuery<T>(CoverartQuery<T>);
 
 /// Direct lookup of all the entities directly linked to another entity
 ///
@@ -202,9 +214,71 @@ where
         self
     }
 
-    pub fn execute(&mut self) -> Result<Coverart, Error> {
+    pub fn front(&mut self) -> &mut Self {
+        if self.0.target.img_type.is_some() {
+            println!("ignoring call to `front`, since coverart type has already been set");
+        }
+        self.0.target.img_type = Some(CoverartType::Front);
+        self
+    }
+
+    pub fn back(&mut self) -> &mut Self {
+        if self.0.target.img_type.is_some() {
+            println!("ignoring call to `back`, since coverart type has already been set");
+        }
+        self.0.target.img_type = Some(CoverartType::Back);
+        self
+    }
+
+    pub fn res_250(&mut self) -> &mut Self {
+        if self.0.target.img_res.is_some() {
+            println!("ignoring call to `res_250`, since resolution has already been set");
+        }
+        self.0.target.img_res = Some(CoverartResolution::Res250);
+        self
+    }
+
+    pub fn res_500(&mut self) -> &mut Self {
+        if self.0.target.img_res.is_some() {
+            println!("ignoring call to `res_500`, since resolution has already been set");
+        }
+        self.0.target.img_res = Some(CoverartResolution::Res500);
+        self
+    }
+
+    pub fn res_1200(&mut self) -> &mut Self {
+        if self.0.target.img_res.is_some() {
+            println!("ignoring call to `res_1200`, since resolution has already been set");
+        }
+        self.0.target.img_res = Some(CoverartResolution::Res1200);
+        self
+    }
+
+    pub fn validate(&mut self) {
+        if let Some(img_type) = &self.0.target.img_type {
+            self.0.path.push_str(&format!("/{}", img_type.as_str()));
+            if let Some(img_res) = &self.0.target.img_res {
+                self.0.path.push_str(&format!("-{}", img_res.as_str()));
+            }
+        } else if self.0.target.img_res.is_some() {
+            // Implicitly assume coverart type as front in the case when resolution is
+            // explicitly specified but coverart type is not.
+            self.front().validate();
+        }
+    }
+
+    pub fn execute(&mut self) -> Result<CoverartResponse, Error> {
+        let coverart_response: CoverartResponse;
+        self.validate();
         let request = HTTP_CLIENT.get(&self.0.path);
-        HTTP_CLIENT.send_with_retries(request)?.json()
+        let mut response = HTTP_CLIENT.send_with_retries(request)?;
+        if self.0.target.img_type.is_some() {
+            let url = response.url().clone();
+            coverart_response = CoverartResponse::Url(url.to_string());
+        } else {
+            coverart_response = CoverartResponse::Json(response.json().unwrap());
+        }
+        Ok(coverart_response)
     }
 }
 
@@ -289,10 +363,13 @@ pub trait FetchCoverart<'a> {
     where
         Self: Sized + Path<'a>,
     {
-        FetchCoverartQuery(Query {
+        FetchCoverartQuery(CoverartQuery {
             path: format!("{}/{}", BASE_COVERART_URL, Self::path()),
             phantom: PhantomData,
-            include: vec![],
+            target: CoverartTarget {
+                img_type: None,
+                img_res: None,
+            },
         })
     }
 
@@ -301,10 +378,13 @@ pub trait FetchCoverart<'a> {
         Self: Sized + Path<'a>,
         Self: Clone,
     {
-        FetchCoverartQuery(Query {
+        FetchCoverartQuery(CoverartQuery {
             path: format!("{}/{}", BASE_COVERART_URL, Self::path()),
             phantom: PhantomData,
-            include: vec![],
+            target: CoverartTarget {
+                img_type: None,
+                img_res: None,
+            },
         })
     }
 }

tests/release/release_coverart.rs

@@ -1,6 +1,7 @@
 extern crate musicbrainz_rs;
 
 use musicbrainz_rs::entity::release::*;
+use musicbrainz_rs::entity::CoverartResponse;
 use musicbrainz_rs::Fetch;
 use musicbrainz_rs::FetchCoverart;
 
@@ -11,8 +12,12 @@ fn should_get_release_coverart() {
         .execute()
         .expect("Unable to get cover art");
 
-    assert_eq!(in_utero_coverart.images[0].front, true);
-    assert_eq!(in_utero_coverart.images[0].back, false);
+    if let CoverartResponse::Json(coverart) = in_utero_coverart {
+        assert_eq!(coverart.images[0].front, true);
+        assert_eq!(coverart.images[0].back, false);
+    } else {
+        assert!(false);
+    }
 }
 
 #[test]
@@ -27,6 +32,10 @@ fn should_get_release_coverart_after_fetch() {
         .execute()
         .expect("Unable to get coverart");
 
-    assert_eq!(in_utero_coverart.images[0].front, true);
-    assert_eq!(in_utero_coverart.images[0].back, false);
+    if let CoverartResponse::Json(coverart) = in_utero_coverart {
+        assert_eq!(coverart.images[0].front, true);
+        assert_eq!(coverart.images[0].back, false);
+    } else {
+        assert!(false);
+    }
 }

tests/release_group/release_group_coverart.rs

@@ -1,9 +1,9 @@
 extern crate musicbrainz_rs;
 
 use musicbrainz_rs::entity::release_group::*;
+use musicbrainz_rs::entity::CoverartResponse;
 use musicbrainz_rs::Fetch;
 use musicbrainz_rs::FetchCoverart;
-use std::{thread, time};
 
 #[test]
 fn should_get_release_group_coverart() {
@@ -12,8 +12,12 @@ fn should_get_release_group_coverart() {
         .execute()
         .expect("Unable to get cover art");
 
-    assert_eq!(echoes_coverart.images[0].front, true);
-    assert_eq!(echoes_coverart.images[0].back, false);
+    if let CoverartResponse::Json(coverart) = echoes_coverart {
+        assert_eq!(coverart.images[0].front, true);
+        assert_eq!(coverart.images[0].back, false);
+    } else {
+        assert!(false);
+    }
 }
 
 #[test]
@@ -28,6 +32,10 @@ fn should_get_release_group_coverart_after_fetch() {
         .execute()
         .expect("Unable to get coverart");
 
-    assert_eq!(echoes_coverart.images[0].front, true);
-    assert_eq!(echoes_coverart.images[0].back, false);
+    if let CoverartResponse::Json(coverart) = echoes_coverart {
+        assert_eq!(coverart.images[0].front, true);
+        assert_eq!(coverart.images[0].back, false);
+    } else {
+        assert!(false);
+    }
 }