Merge pull request #43 from matthiasbeyer/update-serde

Update serde

6 files changed, 89 insertions, 55 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 90f65cb..1ee4f2e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,9 +17,9 @@ license       = "MPL-2.0"
 [dependencies]
 chrono = "0.2"
 log = "0.3"
-serde = "0.8"
-serde_json = "0.8"
-uuid = { version = "0.3", features = ["serde"] }
+serde = "0.9"
+serde_json = "0.9"
+uuid = { version = "0.4", features = ["serde"] }
 
 [dev-dependencies]
 env_logger = "0.3"
diff --git a/src/annotation.rs b/src/annotation.rs
index b2b3b8a..a56c41b 100644
--- a/src/annotation.rs
+++ b/src/annotation.rs
@@ -7,6 +7,8 @@
 //! Module containing types and functions for annotations of tasks
 
 use std::result::Result as RResult;
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
 
 use serde::Serialize;
 use serde::Serializer;
@@ -50,20 +52,22 @@ impl Annotation {
 
 impl Serialize for Annotation {
 
-    fn serialize<S>(&self, serializer: &mut S) -> RResult<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> RResult<S::Ok, S::Error>
         where S: Serializer
     {
+        use serde::ser::SerializeStruct;
+
         let mut state = try!(serializer.serialize_struct("Annotation", 2));
-        try!(serializer.serialize_struct_elt(&mut state, "entry", &self.entry));
-        try!(serializer.serialize_struct_elt(&mut state, "description", &self.description));
-        serializer.serialize_struct_end(state)
+        try!(state.serialize_field("entry", &self.entry));
+        try!(state.serialize_field("description", &self.description));
+        state.end()
     }
 
 }
 
 impl Deserialize for Annotation {
 
-    fn deserialize<D>(deserializer: &mut D) -> RResult<Annotation, D::Error>
+    fn deserialize<D>(deserializer: D) -> RResult<Annotation, D::Error>
         where D: Deserializer
     {
         static FIELDS: &'static [&'static str] = &[
@@ -82,9 +86,15 @@ struct AnnotationDeserializeVisitor;
 impl Visitor for AnnotationDeserializeVisitor {
     type Value = Annotation;
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> RResult<Annotation, V::Error>
+    fn expecting(&self, fmt: &mut Formatter) -> FmtResult {
+        write!(fmt, "a taskwarrior annotation object")
+    }
+
+    fn visit_map<V>(self, mut visitor: V) -> RResult<Annotation, V::Error>
         where V: DeserializeMapVisitor
     {
+        use serde::de::Error;
+
         let mut entry       = None;
         let mut description = None;
 
@@ -114,16 +124,14 @@ impl Visitor for AnnotationDeserializeVisitor {
 
         let entry = match entry {
             Some(entry) => entry,
-            None => try!(visitor.missing_field("entry")),
+            None => return Err(V::Error::missing_field("entry")),
         };
 
         let description = match description {
             Some(description) => description,
-            None => try!(visitor.missing_field("description")),
+            None => return Err(V::Error::missing_field("description")),
         };
 
-        try!(visitor.end());
-
         Ok(Annotation::new(entry, description))
     }
 }
diff --git a/src/date.rs b/src/date.rs
index ec554fb..ed19b86 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -8,6 +8,8 @@
 
 use std::error::Error;
 use std::ops::{Deref, DerefMut};
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
 
 use serde::Serialize;
 use serde::Serializer;
@@ -51,7 +53,7 @@ pub static TASKWARRIOR_DATETIME_TEMPLATE : &'static str = "%Y%m%dT%H%M%SZ";
 
 impl Serialize for Date {
 
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: Serializer
     {
         let formatted = self.0.format(TASKWARRIOR_DATETIME_TEMPLATE);
@@ -62,7 +64,7 @@ impl Serialize for Date {
 
 impl Deserialize for Date {
 
-    fn deserialize<D>(deserializer: &mut D) -> Result<Date, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Date, D::Error>
         where D: Deserializer
     {
         struct DateVisitor;
@@ -70,7 +72,11 @@ impl Deserialize for Date {
         impl Visitor for DateVisitor {
             type Value = Date;
 
-            fn visit_str<E>(&mut self, value: &str) -> Result<Date, E>
+            fn expecting(&self, fmt: &mut Formatter) -> FmtResult {
+                write!(fmt, "a taskwarrior time string")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Date, E>
                 where E: SerdeError
             {
                 NaiveDateTime::parse_from_str(value, TASKWARRIOR_DATETIME_TEMPLATE)
diff --git a/src/priority.rs b/src/priority.rs
index f9f365f..d9a2554 100644
--- a/src/priority.rs
+++ b/src/priority.rs
@@ -10,9 +10,12 @@ use serde::Serialize;
 use serde::ser::Serializer;
 use serde::de::Deserialize;
 use serde::de::Deserializer;
-use serde::Error;
+use serde::de::Error as DeError;
 use serde::de::Visitor;
 
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
+
 /// Enum for the priorities taskwarrior supports.
 #[derive(Debug, Clone, PartialEq)]
 pub enum TaskPriority {
@@ -29,7 +32,7 @@ pub enum TaskPriority {
 
 impl Serialize for TaskPriority {
 
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: Serializer
     {
         serializer.serialize_str(
@@ -45,7 +48,7 @@ impl Serialize for TaskPriority {
 
 impl Deserialize for TaskPriority {
 
-    fn deserialize<D>(deserializer: &mut D) -> Result<TaskPriority, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<TaskPriority, D::Error>
         where D: Deserializer
     {
         struct TaskPriorityVisitor;
@@ -53,14 +56,18 @@ impl Deserialize for TaskPriority {
         impl Visitor for TaskPriorityVisitor {
             type Value = TaskPriority;
 
-            fn visit_str<E>(&mut self, value: &str) -> Result<TaskPriority, E>
-                where E: Error
+            fn expecting(&self, fmt: &mut Formatter) -> FmtResult {
+                write!(fmt, "one of 'L', 'M', 'H'")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<TaskPriority, E>
+                where E: DeError
             {
                 match value {
                     "L" => Ok(TaskPriority::Low),
                     "M" => Ok(TaskPriority::Medium),
                     "H" => Ok(TaskPriority::High),
-                    _ => Err(Error::custom("expected one of 'L', 'M', 'H'")),
+                    _ => Err(DeError::custom("expected one of 'L', 'M', 'H'")),
                 }
             }
         }
diff --git a/src/status.rs b/src/status.rs
index 6212e56..8cdf420 100644
--- a/src/status.rs
+++ b/src/status.rs
@@ -8,6 +8,7 @@
 
 use std::fmt::{Display, Formatter};
 use std::fmt::Error as FmtError;
+use std::fmt::Result as FmtResult;
 
 use serde::Serialize;
 use serde::Serializer;
@@ -50,7 +51,7 @@ impl Display for TaskStatus {
 
 impl Serialize for TaskStatus {
 
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: Serializer
     {
         serializer.serialize_str(
@@ -67,7 +68,7 @@ impl Serialize for TaskStatus {
 }
 
 impl Deserialize for TaskStatus {
-    fn deserialize<D>(deserializer: &mut D) -> Result<TaskStatus, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<TaskStatus, D::Error>
         where D: Deserializer
     {
         struct TaskStatusVisitor;
@@ -75,7 +76,11 @@ impl Deserialize for TaskStatus {
         impl Visitor for TaskStatusVisitor {
             type Value = TaskStatus;
 
-            fn visit_str<E>(&mut self, value: &str) -> Result<TaskStatus, E>
+            fn expecting(&self, fmt: &mut Formatter) -> FmtResult {
+                write!(fmt, "a taskwarrior status ('pending', 'deleted', ...)")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<TaskStatus, E>
                 where E: Error
             {
                 match value {
diff --git a/src/task.rs b/src/task.rs
index 7ddd04c..c28d8ea 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -7,6 +7,8 @@
 //! Module containing `Task` type as well as trait implementations
 
 use std::result::Result as RResult;
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
 
 use serde::Serialize;
 use serde::Serializer;
@@ -238,82 +240,84 @@ impl Task {
 
 impl Serialize for Task {
 
-    fn serialize<S>(&self, serializer: &mut S) -> RResult<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> RResult<S::Ok, S::Error>
         where S: Serializer
     {
+        use serde::ser::SerializeStruct;
+
         let mut state = try!(serializer.serialize_struct("Task", 19));
-        try!(serializer.serialize_struct_elt(&mut state, "status", &self.status));
-        try!(serializer.serialize_struct_elt(&mut state, "uuid", &self.uuid));
-        try!(serializer.serialize_struct_elt(&mut state, "entry", &self.entry));
-        try!(serializer.serialize_struct_elt(&mut state, "description", &self.description));
-        try!(serializer.serialize_struct_elt(&mut state, "annotations", &self.annotations));
-        try!(serializer.serialize_struct_elt(&mut state, "tags", &self.tags));
+        try!(state.serialize_field("status", &self.status));
+        try!(state.serialize_field("uuid", &self.uuid));
+        try!(state.serialize_field("entry", &self.entry));
+        try!(state.serialize_field("description", &self.description));
+        try!(state.serialize_field("annotations", &self.annotations));
+        try!(state.serialize_field("tags", &self.tags));
 
         match self.recur {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "recur", v)),
+            Some(ref v) => try!(state.serialize_field("recur", v)),
             None => { },
         }
         match self.depends {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "depends", v)),
+            Some(ref v) => try!(state.serialize_field("depends", v)),
             None => { },
         }
         match self.due {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "due", v)),
+            Some(ref v) => try!(state.serialize_field("due", v)),
             None => { },
         }
         match self.end {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "end", v)),
+            Some(ref v) => try!(state.serialize_field("end", v)),
             None => { },
         }
         match self.imask {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "imask", v)),
+            Some(ref v) => try!(state.serialize_field("imask", v)),
             None => { },
         }
         match self.mask {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "mask", v)),
+            Some(ref v) => try!(state.serialize_field("mask", v)),
             None => { },
         }
         match self.modified {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "modified", v)),
+            Some(ref v) => try!(state.serialize_field("modified", v)),
             None => { },
         }
         match self.parent {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "parent", v)),
+            Some(ref v) => try!(state.serialize_field("parent", v)),
             None => { },
         }
         match self.priority {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "priority", v)),
+            Some(ref v) => try!(state.serialize_field("priority", v)),
             None => { },
         }
         match self.project {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "project", v)),
+            Some(ref v) => try!(state.serialize_field("project", v)),
             None => { },
         }
         match self.scheduled {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "scheduled", v)),
+            Some(ref v) => try!(state.serialize_field("scheduled", v)),
             None => { },
         }
         match self.start {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "start", v)),
+            Some(ref v) => try!(state.serialize_field("start", v)),
             None => { },
         }
         match self.until {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "until", v)),
+            Some(ref v) => try!(state.serialize_field("until", v)),
             None => { },
         }
         match self.wait {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "wait", v)),
+            Some(ref v) => try!(state.serialize_field("wait", v)),
             None => { },
         }
 
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 
 }
 
 impl Deserialize for Task {
 
-    fn deserialize<D>(deserializer: &mut D) -> RResult<Task, D::Error>
+    fn deserialize<D>(deserializer: D) -> RResult<Task, D::Error>
         where D: Deserializer
     {
         static FIELDS: &'static [&'static str] = &[
@@ -350,9 +354,15 @@ struct TaskDeserializeVisitor;
 impl Visitor for TaskDeserializeVisitor {
     type Value = Task;
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> RResult<Task, V::Error>
+    fn expecting(&self, fmt: &mut Formatter) -> FmtResult {
+        write!(fmt, "a taskwarrior exported JSON object")
+    }
+
+    fn visit_map<V>(self, mut visitor: V) -> RResult<Task, V::Error>
         where V: DeserializeMapVisitor
     {
+        use serde::de::Error;
+
         let mut status      = None;
         let mut uuid        = None;
         let mut entry       = None;
@@ -456,26 +466,24 @@ impl Visitor for TaskDeserializeVisitor {
 
         let status = match status {
             Some(status) => status,
-            None => try!(visitor.missing_field("status")),
+            None => return Err(V::Error::missing_field("status")),
         };
 
         let uuid = match uuid {
             Some(uuid) => uuid,
-            None => try!(visitor.missing_field("uuid")),
+            None => return Err(V::Error::missing_field("uuid")),
         };
 
         let entry = match entry {
             Some(entry) => entry,
-            None => try!(visitor.missing_field("entry")),
+            None => return Err(V::Error::missing_field("entry")),
         };
 
         let description = match description {
             Some(description) => description,
-            None => try!(visitor.missing_field("description")),
+            None => return Err(V::Error::missing_field("description")),
         };
 
-        try!(visitor.end());
-
         let task = Task::new(
             status,
             uuid,