feat(cli): implement tab-completion for ids

tab-completion for files is still kinda misbehaving, it's not handling `~` correctly

Author: AnthonyMichaelTDM

cli/src/handlers/complete.rs

@@ -0,0 +1,217 @@
+//! This module provides functionality for generating completion candidates for
+//! things like the import/export commands in the CLI.
+
+use clap::builder::StyledStr;
+use clap_complete::CompletionCandidate;
+use mecomp_core::rpc::MusicPlayerClient;
+use mecomp_storage::db::schemas::dynamic::query::Compile;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum CompletableTable {
+    Artist,
+    Album,
+    Song,
+    Playlist,
+    DynamicPlaylist,
+    Collection,
+}
+
+/// Generate completion candidates for items in the database,
+/// Given the table name, returns a function that can be used to get completion candidates
+/// from that table.
+pub fn complete_things(table: CompletableTable) -> impl Fn() -> Vec<CompletionCandidate> {
+    move || {
+        let rt = tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .expect("Failed to create Tokio runtime");
+
+        let g = rt.enter();
+
+        let handle = tokio::runtime::Handle::current();
+
+        let client: MusicPlayerClient = match handle.block_on(mecomp_core::rpc::init_client(6600)) {
+            Ok(client) => client,
+            Err(e) => {
+                eprintln!("Failed to connect to daemon: {e}");
+                return vec![];
+            }
+        };
+        let ctx = tarpc::context::current();
+
+        let candidates = match table {
+            CompletableTable::Song => get_song_candidates(&handle, &client, ctx),
+            CompletableTable::Album => get_album_candidates(&handle, &client, ctx),
+            CompletableTable::Artist => get_artist_candidates(&handle, &client, ctx),
+            CompletableTable::Playlist => get_playlist_candidates(&handle, &client, ctx),
+            CompletableTable::DynamicPlaylist => {
+                get_dynamic_playlist_candidates(&handle, &client, ctx)
+            }
+            CompletableTable::Collection => get_collection_candidates(&handle, &client, ctx),
+        };
+        drop(g); // Exit the Tokio runtime context
+
+        candidates
+            .iter()
+            .cloned()
+            .map(|(id, help)| CompletionCandidate::new(id).help(Some(help)))
+            .collect::<Vec<_>>()
+    }
+}
+
+fn get_song_candidates(
+    rt: &tokio::runtime::Handle,
+    client: &MusicPlayerClient,
+    ctx: tarpc::context::Context,
+) -> Vec<(String, StyledStr)> {
+    let response = rt.block_on(client.library_songs_brief(ctx));
+    if let Err(e) = response {
+        eprintln!("Failed to fetch songs: {e}");
+        return vec![];
+    }
+    let songs = response.unwrap().unwrap_or_default();
+
+    songs
+        .into_iter()
+        .map(|song| {
+            (
+                song.id.key().to_string(),
+                StyledStr::from(format!(
+                    "\"{}\" (by: {:?}, album: {})",
+                    song.title, song.artist, song.album
+                )),
+            )
+        })
+        .collect()
+}
+
+fn get_album_candidates(
+    rt: &tokio::runtime::Handle,
+    client: &MusicPlayerClient,
+    ctx: tarpc::context::Context,
+) -> Vec<(String, StyledStr)> {
+    let response = rt.block_on(client.library_albums_brief(ctx));
+    if let Err(e) = response {
+        eprintln!("Failed to fetch albums: {e}");
+        return vec![];
+    }
+    let albums = response.unwrap().unwrap_or_default();
+
+    albums
+        .into_iter()
+        .map(|album| {
+            (
+                album.id.key().to_string(),
+                StyledStr::from(format!(
+                    "\"{}\" (by: {:?}, {} songs)",
+                    album.title, album.artist, album.song_count
+                )),
+            )
+        })
+        .collect()
+}
+
+fn get_artist_candidates(
+    rt: &tokio::runtime::Handle,
+    client: &MusicPlayerClient,
+    ctx: tarpc::context::Context,
+) -> Vec<(String, StyledStr)> {
+    let response = rt.block_on(client.library_artists_brief(ctx));
+    if let Err(e) = response {
+        eprintln!("Failed to fetch artists: {e}");
+        return vec![];
+    }
+    let artists = response.unwrap().unwrap_or_default();
+
+    artists
+        .into_iter()
+        .map(|artist| {
+            (
+                artist.id.key().to_string(),
+                StyledStr::from(format!(
+                    "\"{}\" ({} albums, {} songs)",
+                    artist.name, artist.albums, artist.songs
+                )),
+            )
+        })
+        .collect()
+}
+
+fn get_playlist_candidates(
+    rt: &tokio::runtime::Handle,
+    client: &MusicPlayerClient,
+    ctx: tarpc::context::Context,
+) -> Vec<(String, StyledStr)> {
+    let response = rt.block_on(client.playlist_list(ctx));
+    if let Err(e) = response {
+        eprintln!("Failed to fetch playlists: {e}");
+        return vec![];
+    }
+    let playlists = response.unwrap();
+
+    playlists
+        .into_iter()
+        .map(|playlist| {
+            (
+                playlist.id.key().to_string(),
+                StyledStr::from(format!(
+                    "\"{}\" ({} songs, {:?})",
+                    playlist.name, playlist.songs, playlist.runtime
+                )),
+            )
+        })
+        .collect()
+}
+
+fn get_dynamic_playlist_candidates(
+    rt: &tokio::runtime::Handle,
+    client: &MusicPlayerClient,
+    ctx: tarpc::context::Context,
+) -> Vec<(String, StyledStr)> {
+    let response = rt.block_on(client.dynamic_playlist_list(ctx));
+    if let Err(e) = response {
+        eprintln!("Failed to fetch dynamic playlists: {e}");
+        return vec![];
+    }
+    let playlists = response.unwrap();
+
+    playlists
+        .into_iter()
+        .map(|playlist| {
+            (
+                playlist.id.key().to_string(),
+                StyledStr::from(format!(
+                    "\"{}\" ({})",
+                    playlist.name,
+                    playlist.query.compile_for_storage()
+                )),
+            )
+        })
+        .collect()
+}
+
+fn get_collection_candidates(
+    rt: &tokio::runtime::Handle,
+    client: &MusicPlayerClient,
+    ctx: tarpc::context::Context,
+) -> Vec<(String, StyledStr)> {
+    let response = rt.block_on(client.collection_list(ctx));
+    if let Err(e) = response {
+        eprintln!("Failed to fetch collections: {e}");
+        return vec![];
+    }
+    let collections = response.unwrap();
+
+    collections
+        .into_iter()
+        .map(|collection| {
+            (
+                collection.id.key().to_string(),
+                StyledStr::from(format!(
+                    "\"{}\" ({} songs, {:?})",
+                    collection.name, collection.songs, collection.runtime
+                )),
+            )
+        })
+        .collect()
+}

cli/src/handlers/implementations.rs

@@ -6,7 +6,7 @@ use std::{
 use crate::handlers::{printing, utils};
 
 use super::{
-    Command, CommandHandler, CurrentTarget, LibraryCommand, LibraryGetTarget, LibraryListTarget,
+    Command, CommandHandler, CurrentTarget, LibraryCommand, LibraryGetCommand, LibraryListTarget,
     PlaylistGetMethod, QueueAddTarget, QueueCommand, RandTarget, SearchTarget, SeekCommand,
     VolumeCommand,
 };
@@ -240,12 +240,37 @@ impl CommandHandler for LibraryCommand {
                             printing::song_list("Songs", &resp, false)?
                         )?;
                     }
+                    LibraryListTarget::Playlists => {
+                        let resp: Box<[PlaylistBrief]> = client.playlist_list(ctx).await?;
+                        writeln!(
+                            stdout,
+                            "Daemon response:\n{}",
+                            printing::playlist_brief_list("Playlists", &resp)?
+                        )?;
+                    }
+                    LibraryListTarget::DynamicPlaylists => {
+                        let resp: Box<[DynamicPlaylist]> =
+                            client.dynamic_playlist_list(ctx).await?;
+                        writeln!(
+                            stdout,
+                            "Daemon response:\n{}",
+                            printing::dynamic_playlist_list("Dynamic Playlists", &resp)?
+                        )?;
+                    }
+                    LibraryListTarget::Collections => {
+                        let resp: Box<[CollectionBrief]> = client.collection_list(ctx).await?;
+                        writeln!(
+                            stdout,
+                            "Daemon response:\n{}",
+                            printing::collection_list("Collections", &resp)?
+                        )?;
+                    }
                 }
                 Ok(())
             }
-            Self::Get { target, id } => {
-                match target {
-                    LibraryGetTarget::Artist => {
+            Self::Get { command } => {
+                match command {
+                    LibraryGetCommand::Artist { id } => {
                         let resp: Option<Artist> = client
                             .library_artist_get(
                                 ctx,
@@ -257,7 +282,7 @@ impl CommandHandler for LibraryCommand {
                             .await?;
                         writeln!(stdout, "Daemon response:\n{resp:#?}")?;
                     }
-                    LibraryGetTarget::Album => {
+                    LibraryGetCommand::Album { id } => {
                         let resp: Option<Album> = client
                             .library_album_get(
                                 ctx,
@@ -269,7 +294,7 @@ impl CommandHandler for LibraryCommand {
                             .await?;
                         writeln!(stdout, "Daemon response:\n{resp:#?}")?;
                     }
-                    LibraryGetTarget::Song => {
+                    LibraryGetCommand::Song { id } => {
                         let resp: Option<Song> = client
                             .library_song_get(
                                 ctx,
@@ -281,7 +306,7 @@ impl CommandHandler for LibraryCommand {
                             .await?;
                         writeln!(stdout, "Daemon response:\n{resp:#?}")?;
                     }
-                    LibraryGetTarget::Playlist => {
+                    LibraryGetCommand::Playlist { id } => {
                         let resp: Option<Playlist> = client
                             .playlist_get(
                                 ctx,
@@ -293,6 +318,30 @@ impl CommandHandler for LibraryCommand {
                             .await?;
                         writeln!(stdout, "Daemon response:\n{resp:#?}")?;
                     }
+                    LibraryGetCommand::Dynamic { id } => {
+                        let resp: Option<DynamicPlaylist> = client
+                            .dynamic_playlist_get(
+                                ctx,
+                                RecordId {
+                                    tb: dynamic::TABLE_NAME.to_owned(),
+                                    id: Id::String(id.to_owned()),
+                                },
+                            )
+                            .await?;
+                        writeln!(stdout, "Daemon response:\n{resp:#?}")?;
+                    }
+                    LibraryGetCommand::Collection { id } => {
+                        let resp: Option<Collection> = client
+                            .collection_get(
+                                ctx,
+                                RecordId {
+                                    tb: collection::TABLE_NAME.to_owned(),
+                                    id: Id::String(id.to_owned()),
+                                },
+                            )
+                            .await?;
+                        writeln!(stdout, "Daemon response:\n{resp:#?}")?;
+                    }
                 }
                 Ok(())
             }
@@ -1066,7 +1115,7 @@ impl CommandHandler for super::CollectionCommand {
                 writeln!(
                     stdout,
                     "Daemon response:\n{}",
-                    printing::playlist_collection_list("Collections", &resp)?
+                    printing::collection_list("Collections", &resp)?
                 )?;
                 Ok(())
             }