Merge pull request #40 from matthiasbeyer/update-deps

Update all dependencies

3 files changed, 75 insertions, 150 deletions

diff --git a/Cargo.toml b/Cargo.toml
index e38df0c..b7fdc0c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,12 +15,12 @@ readme        = "./README.md"
 license       = "MPL-2.0"
 
 [dependencies]
-chrono = "0.2.22"
-log = "0.3.6"
-serde = "0.7.13"
-serde_json = "0.7.4"
-uuid = { version = "0.2.2", features = ["serde"] }
+chrono = "0.2"
+log = "0.3"
+serde = "0.8"
+serde_json = "0.8"
+uuid = { version = "0.3", features = ["serde"] }
 
 [dev-dependencies]
-env_logger = "0.3.3"
+env_logger = "0.3"
 
diff --git a/src/annotation.rs b/src/annotation.rs
index a01f02a..b2b3b8a 100644
--- a/src/annotation.rs
+++ b/src/annotation.rs
@@ -13,7 +13,6 @@ use serde::Serializer;
 use serde::Deserialize;
 use serde::Deserializer;
 use serde::de::Visitor;
-use serde::ser::MapVisitor;
 use serde::de::MapVisitor as DeserializeMapVisitor;
 
 use date::Date;
@@ -54,38 +53,10 @@ impl Serialize for Annotation {
     fn serialize<S>(&self, serializer: &mut S) -> RResult<(), S::Error>
         where S: Serializer
     {
-        serializer.serialize_struct("Annotation", AnnotationVisitor {
-            value: self,
-            state: 0,
-        })
-    }
-
-}
-
-/// Helper type for the `Serialize` implementation
-struct AnnotationVisitor<'a> {
-    value: &'a Annotation,
-    state: u8,
-}
-
-impl<'a> MapVisitor for AnnotationVisitor<'a> {
-
-    fn visit<S>(&mut self, serializer: &mut S) -> RResult<Option<()>, S::Error>
-        where S: Serializer
-    {
-        match self.state {
-            0 => {
-                self.state += 1;
-                Ok(Some(try!(serializer.serialize_struct_elt("entry", &self.value.entry))))
-            },
-            1 => {
-                self.state += 1;
-                Ok(Some(try!(serializer.serialize_struct_elt("description", &self.value.description))))
-            },
-            _ => {
-                Ok(None)
-            }
-        }
+        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)
     }
 
 }
diff --git a/src/task.rs b/src/task.rs
index a354437..7ddd04c 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -13,7 +13,6 @@ use serde::Serializer;
 use serde::Deserialize;
 use serde::Deserializer;
 use serde::de::Visitor;
-use serde::ser::MapVisitor;
 use serde::de::MapVisitor as DeserializeMapVisitor;
 use uuid::Uuid;
 
@@ -242,117 +241,72 @@ impl Serialize for Task {
     fn serialize<S>(&self, serializer: &mut S) -> RResult<(), S::Error>
         where S: Serializer
     {
-        serializer.serialize_struct("Task", TaskVisitor {
-            value: self,
-            state: 0,
-        })
-    }
-
-}
-
-/// Helper type for task serialization
-struct TaskVisitor<'a> {
-    value: &'a Task,
-    state: u8,
-}
-
-impl<'a> MapVisitor for TaskVisitor<'a> {
-
-    fn visit<S>(&mut self, serializer: &mut S) -> RResult<Option<()>, S::Error>
-        where S: Serializer
-    {
-        match self.state {
-            0 => {
-                self.state += 1;
-                return Ok(Some(try!(serializer.serialize_struct_elt("status", &self.value.status))))
-            },
-            1 => {
-                self.state += 1;
-                return Ok(Some(try!(serializer.serialize_struct_elt("uuid", &self.value.uuid))))
-            },
-            2 => {
-                self.state += 1;
-                return Ok(Some(try!(serializer.serialize_struct_elt("entry", &self.value.entry))))
-            },
-            3 => {
-                self.state += 1;
-                return Ok(Some(try!(serializer.serialize_struct_elt("description", &self.value.description))))
-            },
-            4 => {
-                self.state += 1;
-                return Ok(Some(try!(serializer.serialize_struct_elt("annotations", &self.value.annotations))))
-            },
-            5 => {
-                self.state += 1;
-                return Ok(Some(try!(serializer.serialize_struct_elt("tags", &self.value.tags))))
-            },
-            _ => loop {
-                debug!("{}", self.state);
-                match self.state {
-                    6 => if self.value.recur.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("recur", &self.value.recur))))
-                    },
-                    7 => if self.value.depends.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("depends", &self.value.depends))))
-                    },
-                    8 => if self.value.due.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("due", &self.value.due))))
-                    },
-                    9 => if self.value.end.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("end", &self.value.end))))
-                    },
-                    10 => if self.value.imask.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("imask", &self.value.imask))))
-                    },
-                    11 => if self.value.mask.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("mask", &self.value.mask))))
-                    },
-                    12 => if self.value.modified.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("modified", &self.value.modified))))
-                    },
-                    13 => if self.value.parent.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("parent", &self.value.parent))))
-                    },
-                    14 => if self.value.priority.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("priority", &self.value.priority))))
-                    },
-                    15 => if self.value.project.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("project", &self.value.project))))
-                    },
-                    16 => if self.value.scheduled.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("scheduled", &self.value.scheduled))))
-                    },
-                    17 => if self.value.start.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("start", &self.value.start))))
-                    },
-                    18 => if self.value.until.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("until", &self.value.until))))
-                    },
-                    19 => if self.value.wait.is_some() {
-                        self.state += 1;
-                        return Ok(Some(try!(serializer.serialize_struct_elt("wait", &self.value.wait))))
-                    },
-
-                    _ => return Ok(None),
-                }
-
-                self.state += 1;
-            }
+        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));
+
+        match self.recur {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "recur", v)),
+            None => { },
+        }
+        match self.depends {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "depends", v)),
+            None => { },
         }
-        Ok(None)
+        match self.due {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "due", v)),
+            None => { },
+        }
+        match self.end {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "end", v)),
+            None => { },
+        }
+        match self.imask {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "imask", v)),
+            None => { },
+        }
+        match self.mask {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "mask", v)),
+            None => { },
+        }
+        match self.modified {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "modified", v)),
+            None => { },
+        }
+        match self.parent {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "parent", v)),
+            None => { },
+        }
+        match self.priority {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "priority", v)),
+            None => { },
+        }
+        match self.project {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "project", v)),
+            None => { },
+        }
+        match self.scheduled {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "scheduled", v)),
+            None => { },
+        }
+        match self.start {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "start", v)),
+            None => { },
+        }
+        match self.until {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "until", v)),
+            None => { },
+        }
+        match self.wait {
+            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "wait", v)),
+            None => { },
+        }
+
+        serializer.serialize_struct_end(state)
     }
 
 }