.gitignore

@@ -9,3 +9,4 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+

.idea/codeStyles/Project.xml

@@ -1,11 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <codeStyleSettings language="XML">
-      <indentOptions>
-        <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="4" />
-        <option name="TAB_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-  </code_scheme>
-</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
-  </state>
-</component>

.idea/google-java-format.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GoogleJavaFormatSettings">
-    <option name="enabled" value="true" />
-  </component>
-</project>

.idea/misc.xml

@@ -3,4 +3,7 @@
   <component name="ProjectRootManager">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
+  <component name="ScalaSbtSettings">
+    <option name="customVMPath" />
+  </component>
 </project>

.idea/sbt.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ScalaSbtSettings">
-    <option name="customVMPath" />
-  </component>
-</project>

.pre-commit-config.yaml

@@ -1,17 +0,0 @@
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
-repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.2.0
-    hooks:
-    -   id: trailing-whitespace
-    -   id: check-merge-conflict
-    -   id: end-of-file-fixer
-    -   id: check-yaml
-    -   id: check-added-large-files
--   repo: https://github.com/doublify/pre-commit-rust
-    rev: v1.0
-    hooks:
-        -   id: fmt
-            args: ['--verbose', '--']
-        -   id: cargo-check

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "songlify"
-version = "0.2.1"
+version = "0.2.0"
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/main.rs

@@ -1,9 +1,8 @@
 use teloxide::prelude::*;
 
-use crate::spotify::TrackInfo;
 use spotify::SpotifyKind::Track;
 
-use crate::spotify::SpotifyKind::{Album, Playlist};
+use crate::spotify::SpotifyKind::Album;
 
 mod spotify;
 
@@ -14,14 +13,14 @@ async fn main() {
 
     let bot = Bot::from_env().auto_send();
     teloxide::repl(bot, |message| async move {
-        let text = message.update.text().and_then(spotify::get_entry_kind);
+        let text = message.update.text().and_then(spotify::get_spotify_entry);
         match text {
             Some(spotify) => {
-                let spotify_client = spotify::get_client();
+                let spotify_client = spotify::get_spotify_client();
                 match spotify {
                     Track(id) => {
                         log::debug!("Parsing spotify song: {}", id);
-                        let track_info = spotify::get_track(spotify_client, &id).await;
+                        let track_info = spotify::get_spotify_track(spotify_client, &id).await;
                         match track_info {
                             Some(info) => {
                                 let reply = format!(
@@ -40,15 +39,14 @@ async fn main() {
                     }
                     Album(id) => {
                         log::debug!("Parsing spotify album: {}", id);
-                        let album_info = spotify::get_album(spotify_client, &id).await;
+                        let album_info = spotify::get_spotify_album(spotify_client, &id).await;
                         match album_info {
                             Some(info) => {
                                 let mut reply = format!(
                                     "Album information:\n\
-                                    🎵 Album name: {}\n\
+                                    🎵 Album name name: {}\n\
-                                    🧑‍🎤 {} artist(s): {}",
+                                🧑‍🎤 Artist(s): {}",
                                     info.name,
-                                    info.artists.len(),
                                     info.artists.join(", ")
                                 );
                                 if !info.genres.is_empty() {
@@ -57,33 +55,15 @@ async fn main() {
                                             .as_str(),
                                     );
                                 }
-                                Some(
+                                if !info.songs.is_empty() {
-                                    message
+                                    let songs = info
-                                        .reply_to(add_track_section(info.tracks, reply))
+                                        .songs
-                                        .await?,
+                                        .iter()
-                                )
+                                        .map(|x| x.name.clone() + "\n")
-                            }
+                                        .collect::<String>();
-                            None => None,
+                                    reply.push_str(format!("\n🎶 Song(s): {}", songs).as_str());
-                        }
+                                }
-                    }
+                                Some(message.reply_to(reply).await?)
-                    Playlist(id) => {
-                        log::debug!("Parsing spotify playlist: {}", id);
-                        let playlist_info = spotify::get_playlist(spotify_client, &id).await;
-                        match playlist_info {
-                            Some(info) => {
-                                let reply = format!(
-                                    "Playlist information:\n\
-                                    ✒️ Playlist name: {}\n\
-                                    🧑‍🎤 {} artist(s): {}",
-                                    info.name,
-                                    info.artists.len(),
-                                    info.artists.join(", ")
-                                );
-                                Some(
-                                    message
-                                        .reply_to(add_track_section(info.tracks, reply))
-                                        .await?,
-                                )
                             }
                             None => None,
                         }
@@ -98,16 +78,3 @@ async fn main() {
 
     log::info!("Exiting...");
 }
-
-fn add_track_section(tracks: Vec<TrackInfo>, reply: String) -> String {
-    if !tracks.is_empty() {
-        let songs = tracks
-            .iter()
-            .map(|x| x.name.clone() + "\n")
-            .collect::<String>();
-        reply
-            .clone()
-            .push_str(format!("\n🎶 {} Track(s): {}", tracks.len(), songs).as_str())
-    }
-    reply
-}

src/spotify/mod.rs

@@ -1,31 +1,10 @@
 use std::time::Duration;
 
-use aspotify::PlaylistItemType::{Episode, Track};
+use aspotify::{Client, ClientCredentials};
-use aspotify::{Client, ClientCredentials, TrackSimplified};
 
 pub enum SpotifyKind {
     Track(String),
     Album(String),
-    Playlist(String),
-}
-
-pub struct TrackInfo {
-    pub(crate) name: String,
-    pub(crate) artists: Vec<String>,
-    pub(crate) duration: Duration,
-}
-
-pub struct AlbumInfo {
-    pub(crate) name: String,
-    pub(crate) artists: Vec<String>,
-    pub(crate) genres: Vec<String>,
-    pub(crate) tracks: Vec<TrackInfo>,
-}
-
-pub struct PlaylistInfo {
-    pub(crate) name: String,
-    pub(crate) artists: Vec<String>,
-    pub(crate) tracks: Vec<TrackInfo>,
 }
 
 fn get_id_in_url(url: &str) -> Option<&str> {
@@ -35,14 +14,7 @@ fn get_id_in_url(url: &str) -> Option<&str> {
         .and_then(|x| x.split('?').next())
 }
 
-fn extract_artists_from_tracks(tracks: Vec<TrackSimplified>) -> Vec<String> {
+pub fn get_spotify_entry(url: &str) -> Option<SpotifyKind> {
-    tracks
-        .iter()
-        .flat_map(|t| t.artists.iter().map(|a| a.name.clone()))
-        .collect()
-}
-
-pub fn get_entry_kind(url: &str) -> Option<SpotifyKind> {
     if url.contains("https://open.spotify.com/track/") {
         let track_id = get_id_in_url(url);
         return match track_id {
@@ -57,24 +29,30 @@ pub fn get_entry_kind(url: &str) -> Option<SpotifyKind> {
             None => None,
         };
     }
-    if url.contains("https://open.spotify.com/playlist/") {
-        let playlist_id = get_id_in_url(url);
-        return match playlist_id {
-            Some(id) => Some(SpotifyKind::Playlist(id.to_string())),
-            None => None,
-        };
-    }
     return None;
 }
 
-pub fn get_client() -> Box<Client> {
+pub fn get_spotify_client() -> Box<Client> {
     let spotify_creds =
         ClientCredentials::from_env().expect("CLIENT_ID and CLIENT_SECRET not found.");
     let spotify_client = Box::new(Client::new(spotify_creds));
     spotify_client
 }
 
-pub async fn get_track(spotify: Box<Client>, id: &String) -> Option<TrackInfo> {
+pub struct TrackInfo {
+    pub(crate) name: String,
+    pub(crate) artists: Vec<String>,
+    pub(crate) duration: Duration,
+}
+
+pub struct AlbumInfo {
+    pub(crate) name: String,
+    pub(crate) artists: Vec<String>,
+    pub(crate) genres: Vec<String>,
+    pub(crate) songs: Vec<TrackInfo>,
+}
+
+pub async fn get_spotify_track(spotify: Box<Client>, id: &String) -> Option<TrackInfo> {
     match spotify.tracks().get_track(id.as_str(), None).await {
         Ok(track) => Some(TrackInfo {
             name: track.data.name,
@@ -85,60 +63,13 @@ pub async fn get_track(spotify: Box<Client>, id: &String) -> Option<TrackInfo> {
     }
 }
 
-pub async fn get_album(spotify: Box<Client>, id: &String) -> Option<AlbumInfo> {
+pub async fn get_spotify_album(spotify: Box<Client>, id: &String) -> Option<AlbumInfo> {
     match spotify.albums().get_album(id.as_str(), None).await {
         Ok(album) => Some(AlbumInfo {
             name: album.data.name,
             artists: album.data.artists.iter().map(|x| x.name.clone()).collect(),
             genres: album.data.genres,
-            tracks: album
+            songs: vec![], // TODO we could lookup songs and put them here!
-                .data
-                .tracks
-                .items
-                .iter()
-                .map(|t| TrackInfo {
-                    name: t.name.clone(),
-                    artists: t.artists.iter().map(|x| x.name.clone()).collect(),
-                    duration: t.duration,
-                })
-                .collect(),
-        }),
-        Err(_e) => None,
-    }
-}
-
-pub async fn get_playlist(spotify: Box<Client>, id: &String) -> Option<PlaylistInfo> {
-    match spotify.playlists().get_playlist(id.as_str(), None).await {
-        Ok(playlist) => Some(PlaylistInfo {
-            name: playlist.data.name,
-            artists: playlist
-                .data
-                .tracks
-                .items
-                .iter()
-                .flat_map(|p| {
-                    p.item.as_ref().map_or(Vec::new(), |x| match x {
-                        Track(t) => extract_artists_from_tracks(vec![t.clone().simplify()]),
-                        Episode(_e) => Vec::new(),
-                    })
-                })
-                .collect(),
-            tracks: playlist
-                .data
-                .tracks
-                .items
-                .iter()
-                .flat_map(|p| {
-                    p.item.as_ref().map_or(None, |x| match x {
-                        Track(t) => Some(TrackInfo {
-                            name: t.name.clone(),
-                            artists: extract_artists_from_tracks(vec![t.clone().simplify()]),
-                            duration: t.duration,
-                        }),
-                        Episode(_e) => None,
-                    })
-                })
-                .collect(),
         }),
         Err(_e) => None,
     }