Merge pull request kstep#12 from tomprince/no-window-in-query

Don't include window and group in Query.

Author: kstep

examples/example.rs

@@ -1,10 +1,11 @@
 extern crate mpd;
 
-use mpd::Client;
+use mpd::{Client, Query};
 use std::net::TcpStream;
 
 fn main() {
     let mut c = Client::new(TcpStream::connect("127.0.0.1:6600").unwrap()).unwrap();
     println!("version: {:?}", c.version);
     println!("status: {:?}", c.status());
+    println!("stuff: {:?}", c.find(&Query::new(), (1, 2)));
 }

src/client.rs

@@ -15,7 +15,7 @@ use output::Output;
 use playlist::Playlist;
 use plugin::Plugin;
 use proto::*;
-use search::Query;
+use search::{Query, Window};
 use song::{Id, Song};
 use stats::Stats;
 use status::{ReplayGain, Status};
@@ -421,19 +421,23 @@ impl<S: Read + Write> Client<S> {
     // TODO: searchaddpl name type what [...], readcomments
 
     /// Find songs matching Query conditions.
-    pub fn find(&mut self, query: &Query) -> Result<Vec<Song>> {
-        self.find_generic("find", query)
+    pub fn find<W>(&mut self, query: &Query, window: W) -> Result<Vec<Song>>
+        where W: Into<Window>
+    {
+        self.find_generic("find", query, window.into())
     }
 
     /// Case-insensitively search for songs matching Query conditions.
-    pub fn search(&mut self, query: &Query) -> Result<Vec<Song>> {
-        self.find_generic("search", query)
+    pub fn search<W>(&mut self, query: &Query, window: W) -> Result<Vec<Song>>
+        where W: Into<Window>
+    {
+        self.find_generic("search", query, window.into())
     }
 
-    fn find_generic(&mut self, cmd: &str, query: &Query) -> Result<Vec<Song>> {
+    fn find_generic(&mut self, cmd: &str, query: &Query, window: Window) -> Result<Vec<Song>> {
         let args = query.to_string();
 
-        self.run_command_fmt(format_args!("{} {}", cmd, args))
+        self.run_command_fmt(format_args!("{}{}{}", cmd, args, window))
             .and_then(|_| {
                 self.read_pairs()
                     .split("file")

src/search.rs

@@ -35,38 +35,34 @@ impl<'a> Filter<'a> {
     }
 }
 
+pub struct Window(Option<(u32, u32)>);
+
+impl From<(u32, u32)> for Window {
+    fn from(window: (u32, u32)) -> Window {
+        Window(Some(window))
+    }
+}
+
+impl From<Option<(u32, u32)>> for Window {
+    fn from(window: Option<(u32, u32)>) -> Window {
+        Window(window)
+    }
+}
+
+#[derive(Default)]
 pub struct Query<'a> {
     filters: Vec<Filter<'a>>,
-    groups: Option<Vec<Cow<'a, str>>>,
-    window: Option<(u32, u32)>,
 }
 
 impl<'a> Query<'a> {
     pub fn new() -> Query<'a> {
-        Query {
-            filters: Vec::new(),
-            groups: None,
-            window: None,
-        }
+        Query { filters: Vec::new() }
     }
 
     pub fn and<'b: 'a, V: 'b + Into<Cow<'b, str>>>(&'a mut self, term: Term<'b>, value: V) -> &'a mut Query<'a> {
         self.filters.push(Filter::new(term, value));
         self
     }
-
-    pub fn limit(&'a mut self, offset: u32, limit: u32) -> &'a mut Query<'a> {
-        self.window = Some((offset, limit));
-        self
-    }
-
-    pub fn group<'b: 'a, G: 'b + Into<Cow<'b, str>>>(&'a mut self, group: G) -> &'a mut Query<'a> {
-        match self.groups {
-            None => self.groups = Some(vec![group.into()]),
-            Some(ref mut groups) => groups.push(group.into()),
-        };
-        self
-    }
 }
 
 impl<'a> fmt::Display for Term<'a> {
@@ -92,16 +88,15 @@ impl<'a> fmt::Display for Query<'a> {
         for filter in &self.filters {
             try!(filter.fmt(f));
         }
+        Ok(())
+    }
+}
 
-        if let Some(ref groups) = self.groups {
-            for group in groups {
-                try!(write!(f, " group {}", group));
-            }
-        }
-
-        match self.window {
-            Some((a, b)) => write!(f, " window {}:{}", a, b),
-            None => Ok(()),
+impl fmt::Display for Window {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some((a, b)) = self.0 {
+            write!(f, " window {}:{}", a, b)?;
         }
+        Ok(())
     }
 }

tests/search.rs

@@ -3,41 +3,28 @@ extern crate mpd;
 mod helpers;
 use helpers::connect;
 use mpd::{Query, Term};
+use mpd::search::Window;
 
 #[test]
 fn search() {
     let mut mpd = connect();
     let mut query = Query::new();
-    // query.and(mpd::Term::Any, "Soul");
-    let songs = mpd.find(&query);
+    let query = query.and(mpd::Term::Any, "Soul");
+    let songs = mpd.find(query, None);
     println!("{:?}", songs);
+    assert!(songs.is_ok());
 }
 
 #[test]
 fn find_query_format() {
     let mut query = Query::new();
     let finished = query.and(Term::Tag("albumartist".into()), "Mac DeMarco")
-        .and(Term::Tag("album".into()), "Salad Days")
-        .limit(0, 2);
-    assert_eq!(&finished.to_string(), " albumartist \"Mac DeMarco\" album \"Salad Days\" window 0:2");
+        .and(Term::Tag("album".into()), "Salad Days");
+    assert_eq!(&finished.to_string(), " albumartist \"Mac DeMarco\" album \"Salad Days\"");
 }
 
 #[test]
-fn count_query_format() {
-    let mut query = Query::new();
-    let finished = query.and(Term::Tag("artist".into()), "Courtney Barnett")
-        .group("album");
-    assert_eq!(&finished.to_string(), " artist \"Courtney Barnett\" group album");
+fn find_window_format() {
+    let window: Window = (0, 2).into();
+    assert_eq!(&window.to_string(), " window 0:2");
 }
-
-// #[test]
-// fn count() {
-// let mut mpd = connect();
-// let song = mpd.search(mpd::Query {
-// clauses: vec![mpd::Clause(mpd::Term::Any, "Soul".to_owned())],
-// window: None,
-// group: None
-// }).unwrap();
-// println!("{:?}", song);
-// }
-//