From 424ba3ae2596854514767c824ac2a24d5abb355d Mon Sep 17 00:00:00 2001
From: johannesd3 <johannesd@outlook.com>
Date: Thu, 21 Jan 2021 22:07:16 +0100
Subject: [PATCH] Migrated metadata crate to futures 0.3

---
 metadata/Cargo.toml |  3 +-
 metadata/src/lib.rs | 97 ++++++++++++++++++++-------------------------
 2 files changed, 45 insertions(+), 55 deletions(-)

diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml
index 8f3b4c93..f5e61237 100644
--- a/metadata/Cargo.toml
+++ b/metadata/Cargo.toml
@@ -8,8 +8,9 @@ repository = "https://github.com/librespot-org/librespot"
 edition = "2018"
 
 [dependencies]
+async-trait = "0.1"
 byteorder = "1.3"
-futures = "0.1"
+futures = "0.3"
 linear-map = "1.2"
 protobuf = "~2.14.0"
 log = "0.4"
diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs
index 8bd422ce..f71bae95 100644
--- a/metadata/src/lib.rs
+++ b/metadata/src/lib.rs
@@ -1,6 +1,11 @@
+#![allow(clippy::unused_io_amount)]
+#![allow(clippy::redundant_field_names)]
 #[macro_use]
 extern crate log;
 
+#[macro_use]
+extern crate async_trait;
+
 extern crate byteorder;
 extern crate futures;
 extern crate linear_map;
@@ -11,8 +16,6 @@ extern crate librespot_protocol as protocol;
 
 pub mod cover;
 
-use futures::future;
-use futures::Future;
 use linear_map::LinearMap;
 
 use librespot_core::mercury::MercuryError;
@@ -69,81 +72,67 @@ pub struct AudioItem {
 }
 
 impl AudioItem {
-    pub fn get_audio_item(
-        session: &Session,
-        id: SpotifyId,
-    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>> {
+    pub async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<Self, MercuryError> {
         match id.audio_type {
-            SpotifyAudioType::Track => Track::get_audio_item(session, id),
-            SpotifyAudioType::Podcast => Episode::get_audio_item(session, id),
-            SpotifyAudioType::NonPlayable => {
-                Box::new(future::err::<AudioItem, MercuryError>(MercuryError))
-            }
+            SpotifyAudioType::Track => Track::get_audio_item(session, id).await,
+            SpotifyAudioType::Podcast => Episode::get_audio_item(session, id).await,
+            SpotifyAudioType::NonPlayable => Err(MercuryError),
         }
     }
 }
 
+#[async_trait]
 trait AudioFiles {
-    fn get_audio_item(
-        session: &Session,
-        id: SpotifyId,
-    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>>;
+    async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<AudioItem, MercuryError>;
 }
 
+#[async_trait]
 impl AudioFiles for Track {
-    fn get_audio_item(
-        session: &Session,
-        id: SpotifyId,
-    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>> {
-        Box::new(Self::get(session, id).and_then(move |item| {
-            Ok(AudioItem {
-                id: id,
-                uri: format!("spotify:track:{}", id.to_base62()),
-                files: item.files,
-                name: item.name,
-                duration: item.duration,
-                available: item.available,
-                alternatives: Some(item.alternatives),
-            })
-        }))
+    async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<AudioItem, MercuryError> {
+        let item = Self::get(session, id).await?;
+        Ok(AudioItem {
+            id: id,
+            uri: format!("spotify:track:{}", id.to_base62()),
+            files: item.files,
+            name: item.name,
+            duration: item.duration,
+            available: item.available,
+            alternatives: Some(item.alternatives),
+        })
     }
 }
 
+#[async_trait]
 impl AudioFiles for Episode {
-    fn get_audio_item(
-        session: &Session,
-        id: SpotifyId,
-    ) -> Box<dyn Future<Item = AudioItem, Error = MercuryError>> {
-        Box::new(Self::get(session, id).and_then(move |item| {
-            Ok(AudioItem {
-                id: id,
-                uri: format!("spotify:episode:{}", id.to_base62()),
-                files: item.files,
-                name: item.name,
-                duration: item.duration,
-                available: item.available,
-                alternatives: None,
-            })
-        }))
+    async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<AudioItem, MercuryError> {
+        let item = Self::get(session, id).await?;
+
+        Ok(AudioItem {
+            id: id,
+            uri: format!("spotify:episode:{}", id.to_base62()),
+            files: item.files,
+            name: item.name,
+            duration: item.duration,
+            available: item.available,
+            alternatives: None,
+        })
     }
 }
+
+#[async_trait]
 pub trait Metadata: Send + Sized + 'static {
     type Message: protobuf::Message;
 
     fn request_url(id: SpotifyId) -> String;
     fn parse(msg: &Self::Message, session: &Session) -> Self;
 
-    fn get(session: &Session, id: SpotifyId) -> Box<dyn Future<Item = Self, Error = MercuryError>> {
+    async fn get(session: &Session, id: SpotifyId) -> Result<Self, MercuryError> {
         let uri = Self::request_url(id);
-        let request = session.mercury().get(uri);
+        let response = session.mercury().get(uri).await?;
+        let data = response.payload.first().expect("Empty payload");
+        let msg: Self::Message = protobuf::parse_from_bytes(data).unwrap();
 
-        let session = session.clone();
-        Box::new(request.and_then(move |response| {
-            let data = response.payload.first().expect("Empty payload");
-            let msg: Self::Message = protobuf::parse_from_bytes(data).unwrap();
-
-            Ok(Self::parse(&msg, &session))
-        }))
+        Ok(Self::parse(&msg, &session))
     }
 }