Merge pull request #39 from phi-gamma/modernize

Adapt for more recent Rust releases

Cargo.toml

@@ -6,12 +6,13 @@ homepage = "https://github.com/kstep/rust-mpd"
 license = "MIT/Apache-2.0"
 name = "mpd"
 repository = "https://github.com/kstep/rust-mpd.git"
-version = "0.0.12"
+version = "0.1.0"
+edition = "2018"
 
 [dependencies]
 bufstream = "0.1.1"
 rustc-serialize = "0.3.16"
-time = "0.1.34"
+time = "0.2"
 
 [dev-dependencies]
 tempdir = "0.3.5"

src/client.rs

@@ -7,24 +7,25 @@
 
 use bufstream::BufStream;
 
-use convert::*;
-use error::{Error, ProtoError, Result};
-use message::{Channel, Message};
-use mount::{Mount, Neighbor};
-use output::Output;
-use playlist::Playlist;
-use plugin::Plugin;
-use proto::*;
-use search::{Query, Window, Term};
-use song::{Id, Song};
-use stats::Stats;
-use status::{ReplayGain, Status};
+use crate::convert::*;
+use crate::error::{Error, ProtoError, Result};
+use crate::message::{Channel, Message};
+use crate::mount::{Mount, Neighbor};
+use crate::output::Output;
+use crate::playlist::Playlist;
+use crate::plugin::Plugin;
+use crate::proto::*;
+use crate::search::{Query, Window, Term};
+use crate::song::{Id, Song};
+use crate::stats::Stats;
+use crate::status::{ReplayGain, Status};
+use crate::sticker::Sticker;
+use crate::version::Version;
+
 use std::convert::From;
 use std::io::{BufRead, Lines, Read, Write};
 use std::net::{TcpStream, ToSocketAddrs};
 use std::collections::HashMap;
-use sticker::Sticker;
-use version::Version;
 
 // Client {{{
 
@@ -58,13 +59,13 @@ impl<S: Read + Write> Client<S> {
         let mut socket = BufStream::new(socket);
 
         let mut banner = String::new();
-        try!(socket.read_line(&mut banner));
+        socket.read_line(&mut banner)?;
 
         if !banner.starts_with("OK MPD ") {
             return Err(From::from(ProtoError::BadBanner));
         }
 
-        let version = try!(banner[7..].trim().parse::<Version>());
+        let version = banner[7..].trim().parse::<Version>()?;
 
         Ok(Client {
                socket: socket,
@@ -610,7 +611,7 @@ impl<S: Read + Write> Proto for Client<S> {
 
     fn read_line(&mut self) -> Result<String> {
         let mut buf = String::new();
-        try!(self.socket.read_line(&mut buf));
+        self.socket.read_line(&mut buf)?;
         if buf.ends_with('\n') {
             buf.pop();
         }

src/convert.rs

@@ -1,15 +1,15 @@
 #![allow(missing_docs)]
 //! These are inner traits to support methods overloading for the `Client`
 
-use error::Error;
-use output::Output;
-use playlist::Playlist;
-use proto::ToArguments;
-use song::{self, Id, Song};
+use crate::error::Error;
+use crate::output::Output;
+use crate::playlist::Playlist;
+use crate::proto::ToArguments;
+use crate::song::{self, Id, Song};
 use std::collections::BTreeMap;
 use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
 
-use time::Duration;
+use std::time::Duration;
 
 #[doc(hidden)]
 pub trait FromMap: Sized {
@@ -88,7 +88,7 @@ impl ToSeconds for f64 {
 
 impl ToSeconds for Duration {
     fn to_seconds(self) -> f64 {
-        self.num_milliseconds() as f64 / 1000.0
+        self.as_secs_f64()
     }
 }
 // }}}
@@ -243,7 +243,7 @@ impl ToSongRange for Range<Duration> {
 
 impl ToSongRange for Range<u32> {
     fn to_range(self) -> song::Range {
-        song::Range(Duration::seconds(self.start as i64), Some(Duration::seconds(self.end as i64)))
+        song::Range(Duration::from_secs(self.start as u64), Some(Duration::from_secs(self.end as u64)))
     }
 }
 
@@ -255,25 +255,25 @@ impl ToSongRange for RangeFrom<Duration> {
 
 impl ToSongRange for RangeFrom<u32> {
     fn to_range(self) -> song::Range {
-        song::Range(Duration::seconds(self.start as i64), None)
+        song::Range(Duration::from_secs(self.start as u64), None)
     }
 }
 
 impl ToSongRange for RangeTo<Duration> {
     fn to_range(self) -> song::Range {
-        song::Range(Duration::zero(), Some(self.end))
+        song::Range(Duration::from_secs(0), Some(self.end))
     }
 }
 
 impl ToSongRange for RangeTo<u32> {
     fn to_range(self) -> song::Range {
-        song::Range(Duration::zero(), Some(Duration::seconds(self.end as i64)))
+        song::Range(Duration::from_secs(0), Some(Duration::from_secs(self.end as u64)))
     }
 }
 
 impl ToSongRange for RangeFull {
     fn to_range(self) -> song::Range {
-        song::Range(Duration::zero(), None)
+        song::Range(Duration::from_secs(0), None)
     }
 }
 
@@ -301,7 +301,7 @@ impl<'a, T: ToSongPath> ToSongPath for &'a T {
     }
 }
 
-impl ToSongPath for AsRef<str> {
+impl ToSongPath for dyn AsRef<str> {
     fn to_path(&self) -> &str {
         self.as_ref()
     }

src/error.rs

@@ -21,6 +21,7 @@ use std::result;
 use std::str::FromStr;
 use std::string::ParseError as StringParseError;
 use time::ParseError as TimeParseError;
+use time::ConversionRangeError as TimeConversionRangeError;
 
 // Server errors {{{
 /// Server error codes, as defined in [libmpdclient](http://www.musicpd.org/doc/libmpdclient/protocol_8h_source.html)
@@ -56,7 +57,7 @@ impl FromStr for ErrorCode {
     type Err = ParseError;
     fn from_str(s: &str) -> result::Result<ErrorCode, ParseError> {
         use self::ErrorCode::*;
-        match try!(s.parse()) {
+        match s.parse()? {
             1 => Ok(NotList),
             2 => Ok(Argument),
             3 => Ok(Password),
@@ -76,10 +77,13 @@ impl FromStr for ErrorCode {
     }
 }
 
-impl StdError for ErrorCode {
-    fn description(&self) -> &str {
+impl StdError for ErrorCode { }
+
+impl fmt::Display for ErrorCode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::ErrorCode::*;
-        match *self {
+
+        let desc = match *self {
             NotList => "not a list",
             Argument => "invalid argument",
             Password => "invalid password",
@@ -93,13 +97,9 @@ impl StdError for ErrorCode {
             UpdateAlready => "already updating",
             PlayerSync => "player syncing",
             Exist => "already exists",
-        }
-    }
-}
+        };
 
-impl fmt::Display for ErrorCode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(self.description())
+        f.write_str(desc)
     }
 }
 
@@ -116,18 +116,14 @@ pub struct ServerError {
     pub detail: String,
 }
 
+impl StdError for ServerError { }
+
 impl fmt::Display for ServerError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{} error (`{}') at {}", self.code, self.detail, self.pos)
     }
 }
 
-impl StdError for ServerError {
-    fn description(&self) -> &str {
-        self.code.description()
-    }
-}
-
 impl FromStr for ServerError {
     type Err = ParseError;
     fn from_str(s: &str) -> result::Result<ServerError, ParseError> {
@@ -182,22 +178,14 @@ pub enum Error {
 pub type Result<T> = result::Result<T, Error>;
 
 impl StdError for Error {
-    fn cause(&self) -> Option<&StdError> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
         match *self {
             Error::Io(ref err) => Some(err),
             Error::Parse(ref err) => Some(err),
             Error::Proto(ref err) => Some(err),
             Error::Server(ref err) => Some(err),
         }
     }
-    fn description(&self) -> &str {
-        match *self {
-            Error::Io(ref err) => err.description(),
-            Error::Parse(ref err) => err.description(),
-            Error::Proto(ref err) => err.description(),
-            Error::Server(ref err) => err.description(),
-        }
-    }
 }
 
 impl fmt::Display for Error {
@@ -247,6 +235,12 @@ impl From<ServerError> for Error {
         Error::Server(e)
     }
 }
+
+impl From<TimeConversionRangeError> for Error {
+    fn from(e: TimeConversionRangeError) -> Error {
+        Error::Parse(ParseError::BadTimeConversion(e))
+    }
+}
 // }}}
 
 // Parse errors {{{
@@ -261,6 +255,8 @@ pub enum ParseError {
     BadValue(String),
     /// date/time parsing error
     BadTime(TimeParseError),
+    /// date/time to duration (Unix time) conversion error
+    BadTimeConversion(TimeConversionRangeError),
     /// invalid version format (should be x.y.z)
     BadVersion,
     /// the response is not an `ACK` (not an error)
@@ -296,20 +292,18 @@ pub enum ParseError {
     BadErrorCode(usize),
 }
 
+impl StdError for ParseError { }
+
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
-    }
-}
-
-impl StdError for ParseError {
-    fn description(&self) -> &str {
         use self::ParseError::*;
-        match *self {
+
+        let desc = match *self {
             BadInteger(_) => "invalid integer",
             BadFloat(_) => "invalid float",
             BadValue(_) => "invalid value",
             BadTime(_) => "invalid date/time",
+            BadTimeConversion(_) => "invalid date/time conversion",
             BadVersion => "invalid version",
             NotAck => "not an ACK",
             BadPair => "invalid pair",
@@ -325,7 +319,9 @@ impl StdError for ParseError {
             BadChans(_) => "invalid audio format channels",
             BadState(_) => "invalid playing state",
             BadErrorCode(_) => "unknown error code",
-        }
+        };
+
+        write!(f, "{}", desc)
     }
 }
 
@@ -335,6 +331,12 @@ impl From<TimeParseError> for ParseError {
     }
 }
 
+impl From<TimeConversionRangeError> for ParseError {
+    fn from(e: TimeConversionRangeError) -> ParseError {
+        ParseError::BadTimeConversion(e)
+    }
+}
+
 impl From<ParseIntError> for ParseError {
     fn from(e: ParseIntError) -> ParseError {
         ParseError::BadInteger(e)
@@ -374,21 +376,19 @@ pub enum ProtoError {
     BadSticker,
 }
 
+impl StdError for ProtoError { }
+
 impl fmt::Display for ProtoError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
-    }
-}
-
-impl StdError for ProtoError {
-    fn description(&self) -> &str {
-        match *self {
+        let desc = match *self {
             ProtoError::NotOk => "OK expected",
             ProtoError::NotPair => "pair expected",
             ProtoError::BadBanner => "banner error",
             ProtoError::NoField(_) => "missing field",
             ProtoError::BadSticker => "sticker error",
-        }
+        };
+
+        write!(f, "{}", desc)
     }
 }
 // }}}

src/idle.rs

@@ -26,10 +26,10 @@
 //! to original `Client` struct, thus enforcing MPD contract in regards of (im)possibility
 //! to send commands while in "idle" mode.
 
-use client::Client;
+use crate::client::Client;
+use crate::error::{Error, ParseError};
+use crate::proto::Proto;
 
-use error::{Error, ParseError};
-use proto::Proto;
 use std::fmt;
 use std::io::{Read, Write};
 use std::mem::forget;
@@ -110,7 +110,7 @@ impl fmt::Display for Subsystem {
 }
 
 use std::result::Result as StdResult;
-impl<'a> ::proto::ToArguments for Subsystem {
+impl<'a> crate::proto::ToArguments for Subsystem {
     fn to_arguments<F, E>(&self, f: &mut F) -> StdResult<(), E>
         where F: FnMut(&str) -> StdResult<(), E>
     {

src/lib.rs

@@ -32,10 +32,6 @@
 //! # }
 //! ```
 
-extern crate rustc_serialize;
-extern crate time;
-extern crate bufstream;
-
 mod macros;
 mod convert;
 pub mod error;