Add some more commands.

src/client.rs

@@ -15,7 +15,7 @@ use output::Output;
 use playlist::Playlist;
 use plugin::Plugin;
 use proto::*;
-use search::{Query, Window};
+use search::{Query, Window, Term};
 use song::{Id, Song};
 use stats::Stats;
 use status::{ReplayGain, Status};
@@ -237,8 +237,8 @@ impl<S: Read + Write> Client<S> {
     }
 
     /// Append a song into a queue
-    pub fn push<P: AsRef<str>>(&mut self, path: P) -> Result<Id> {
-        self.run_command("addid", path.as_ref())
+    pub fn push<P: ToSongPath>(&mut self, path: P) -> Result<Id> {
+        self.run_command("addid", path)
             .and_then(|_| self.read_field("Id"))
             .and_then(|v| {
                 self.expect_ok()
@@ -247,8 +247,8 @@ impl<S: Read + Write> Client<S> {
     }
 
     /// Insert a song into a given position in a queue
-    pub fn insert<P: AsRef<str>>(&mut self, path: P, pos: usize) -> Result<usize> {
-        self.run_command("addid", (path.as_ref(), pos))
+    pub fn insert<P: ToSongPath>(&mut self, path: P, pos: usize) -> Result<usize> {
+        self.run_command("addid", (path, pos))
             .and_then(|_| self.read_field("Id"))
             .and_then(|v| {
                 self.expect_ok()
@@ -383,8 +383,8 @@ impl<S: Read + Write> Client<S> {
     }
 
     /// Add new songs to a playlist
-    pub fn pl_push<N: ToPlaylistName, P: AsRef<str>>(&mut self, name: N, path: P) -> Result<()> {
-        self.run_command("playlistadd", (name.to_name(), path.as_ref()))
+    pub fn pl_push<N: ToPlaylistName, P: ToSongPath>(&mut self, name: N, path: P) -> Result<()> {
+        self.run_command("playlistadd", (name.to_name(), path))
             .and_then(|_| self.expect_ok())
     }
 
@@ -427,7 +427,7 @@ impl<S: Read + Write> Client<S> {
     // Database search {{{
     // TODO: count tag needle [...] [group] [grouptag], find type what [...] [window start:end]
     // TODO: search type what [...] [window start:end], searchadd type what [...]
-    // TODO: findadd type what [...], listallinfo [uri], listfiles [uri], lsinfo [uri]
+    // TODO: listallinfo [uri], listfiles [uri]
     // TODO: list type [filtertype] [filterwhat] [...] [group] [grouptype] [...]
     // TODO: searchaddpl name type what [...], readcomments
 
@@ -455,6 +455,26 @@ impl<S: Read + Write> Client<S> {
             })
     }
 
+    /// Lists unique tags values of the specified type for songs matching the given query.
+    // TODO: list type [filtertype] [filterwhat] [...] [group] [grouptype] [...]
+    // It isn't clear if or how `group` works
+    pub fn list(&mut self, term: &Term, query: &Query) -> Result<Vec<String>> {
+        self.run_command("list", (term, query))
+            .and_then(|_| self.read_pairs().map(|p| p.map(|p| p.1)).collect())
+    }
+
+    /// Find all songs in the db that match query and adds them to current playlist.
+    pub fn findadd(&mut self, query: &Query) -> Result<()> {
+        self.run_command("findadd", query)
+            .and_then(|_| self.expect_ok())
+    }
+
+    /// Lists the contents of a directory.
+    pub fn lsinfo<P: ToSongPath>(&mut self, path: P) -> Result<Song> {
+        self.run_command("lsinfo", path)
+            .and_then(|_| self.read_struct())
+    }
+
     // }}}
 
     // Output methods {{{

src/convert.rs

@@ -4,6 +4,7 @@
 use error::Error;
 use output::Output;
 use playlist::Playlist;
+use proto::ToArguments;
 use song::{self, Id, Song};
 use std::collections::BTreeMap;
 use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
@@ -281,4 +282,35 @@ impl ToSongRange for song::Range {
         self
     }
 }
+
 // }}}
+
+pub trait ToSongPath {
+    fn to_path(&self) -> &str;
+}
+
+impl ToSongPath for Song {
+    fn to_path(&self) -> &str {
+        &self.file
+    }
+}
+
+impl<'a, T: ToSongPath> ToSongPath for &'a T {
+    fn to_path(&self) -> &str {
+        (*self).to_path()
+    }
+}
+
+impl ToSongPath for AsRef<str> {
+    fn to_path(&self) -> &str {
+        self.as_ref()
+    }
+}
+
+impl<T: ToSongPath> ToArguments for T {
+    fn to_arguments<F, E>(&self, f: &mut F) -> Result<(), E>
+        where F: FnMut(&str) -> Result<(), E>
+    {
+        self.to_path().to_arguments(f)
+    }
+}

src/search.rs

@@ -73,11 +73,19 @@ impl<'a> fmt::Display for Term<'a> {
     }
 }
 
+impl<'a> ToArguments for &'a Term<'a> {
+    fn to_arguments<F, E>(&self, f: &mut F) -> StdResult<(), E>
+        where F: FnMut(&str) -> StdResult<(), E>
+    {
+        f(&self.to_string())
+    }
+}
+
 impl<'a> ToArguments for &'a Filter<'a> {
     fn to_arguments<F, E>(&self, f: &mut F) -> StdResult<(), E>
         where F: FnMut(&str) -> StdResult<(), E>
     {
-        f(&self.typ.to_string())?;
+        (&self.typ).to_arguments(f)?;
         f(&self.what)
     }
 }