Run `cargo fmt`

Suggested-by: Dheepak Krishnamurthy <me@kdheepak.com>
Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

10 files changed, 114 insertions, 117 deletions

diff --git a/examples/create_task.rs b/examples/create_task.rs
index 91082cb..e95aedd 100644
--- a/examples/create_task.rs
+++ b/examples/create_task.rs
@@ -1,10 +1,10 @@
-extern crate task_hookrs;
 extern crate chrono;
 extern crate serde_json;
+extern crate task_hookrs;
 extern crate uuid;
 
-use task_hookrs::task::Task;
 use task_hookrs::status::TaskStatus;
+use task_hookrs::task::Task;
 use task_hookrs::uda::UDA;
 
 use chrono::NaiveDateTime;
diff --git a/examples/import_task.rs b/examples/import_task.rs
index ca6ba04..c806bf6 100644
--- a/examples/import_task.rs
+++ b/examples/import_task.rs
@@ -1,12 +1,12 @@
-extern crate task_hookrs;
 extern crate chrono;
 extern crate serde_json;
+extern crate task_hookrs;
 extern crate uuid;
 
 use std::io::stdin;
 
-use task_hookrs::status::TaskStatus;
 use task_hookrs::import::import;
+use task_hookrs::status::TaskStatus;
 
 fn main() {
     let mut tasks = import(stdin()).unwrap();
diff --git a/src/date.rs b/src/date.rs
index ff99cb8..717ca37 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -8,13 +8,13 @@
 
 use std::ops::{Deref, DerefMut};
 
-use serde::Serialize;
-use serde::Serializer;
+use chrono::NaiveDateTime;
+use serde::de::Error as SerdeError;
+use serde::de::Visitor;
 use serde::Deserialize;
 use serde::Deserializer;
-use serde::de::Visitor;
-use serde::de::Error as SerdeError;
-use chrono::NaiveDateTime;
+use serde::Serialize;
+use serde::Serializer;
 
 /// Date is a NaiveDateTime-Wrapper object to be able to implement foreign traits on it
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
diff --git a/src/error.rs b/src/error.rs
index 2ed9bd5..af4dfd5 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -9,7 +9,6 @@
 /// Failure error kind type, defining error messages
 #[derive(Debug, Clone, Eq, PartialEq, Fail)]
 pub enum ErrorKind {
-
     /// Error kind indicating that the JSON parser failed
     #[fail(display = "Failed to create a Task from JSON")]
     ParserError,
@@ -24,6 +23,5 @@ pub enum ErrorKind {
 
     /// Error kind indicating that a conversion to JSON failed
     #[fail(display = "A Task could not be converted to JSON")]
-    SerializeError
+    SerializeError,
 }
-
diff --git a/src/import.rs b/src/import.rs
index 3d6c4e9..943d0aa 100644
--- a/src/import.rs
+++ b/src/import.rs
@@ -9,23 +9,27 @@
 use std::io::BufRead;
 use std::io::Read;
 
-use serde_json;
+use failure::Error;
 use failure::Fallible as Result;
 use failure::ResultExt;
-use failure::Error;
+use serde_json;
 
-use task::Task;
 use error::ErrorKind as EK;
+use task::Task;
 
 /// Import taskwarrior-exported JSON. This expects an JSON Array of objects, as exported by
 /// taskwarrior.
 pub fn import<R: Read>(r: R) -> Result<Vec<Task>> {
-    serde_json::from_reader(r).context(EK::ParserError).map_err(Error::from)
+    serde_json::from_reader(r)
+        .context(EK::ParserError)
+        .map_err(Error::from)
 }
 
 /// Import a single JSON-formatted Task
 pub fn import_task(s: &str) -> Result<Task> {
-    serde_json::from_str(s).context(EK::ParserError).map_err(Error::from)
+    serde_json::from_str(s)
+        .context(EK::ParserError)
+        .map_err(Error::from)
 }
 
 /// Reads line by line and tries to parse a task-object per line.
@@ -33,7 +37,11 @@ pub fn import_tasks<BR: BufRead>(r: BR) -> Vec<Result<Task>> {
     let mut vt = Vec::new();
     for line in r.lines() {
         if line.is_err() {
-            vt.push(Err(line.unwrap_err()).context(EK::ReaderError).map_err(Error::from));
+            vt.push(
+                Err(line.unwrap_err())
+                    .context(EK::ReaderError)
+                    .map_err(Error::from),
+            );
             continue;
         }
         // Unwrap is safe because of continue above
@@ -127,11 +135,11 @@ fn test_two() {
 
 #[test]
 fn test_one_single() {
-    use status::TaskStatus;
+    use chrono::NaiveDateTime;
     use date::Date;
     use date::TASKWARRIOR_DATETIME_TEMPLATE;
+    use status::TaskStatus;
     use uuid::Uuid;
-    use chrono::NaiveDateTime;
     fn mkdate(s: &str) -> Date {
         let n = NaiveDateTime::parse_from_str(s, TASKWARRIOR_DATETIME_TEMPLATE);
         Date::from(n.unwrap())
@@ -165,9 +173,7 @@ fn test_one_single() {
     assert!(task.project() == Some(&String::from("someproject")));
     if let Some(tags) = task.tags() {
         for tag in tags {
-            let any_tag = ["some", "tags", "are", "here"].iter().any(
-                |t| tag == *t,
-            );
+            let any_tag = ["some", "tags", "are", "here"].iter().any(|t| tag == *t);
             assert!(any_tag, "Tag {} missing", tag);
         }
     } else {
@@ -179,8 +185,8 @@ fn test_one_single() {
 
 #[test]
 fn test_two_single() {
-    use std::io::BufReader;
     use status::TaskStatus;
+    use std::io::BufReader;
     let s = r#"
 {"id":1,"description":"some description","entry":"20150619T165438Z","modified":"20160327T164007Z","project":"someproject","status":"waiting","tags":["some","tags","are","here"],"uuid":"8ca953d5-18b4-4eb9-bd56-18f2e5b752f0","wait":"20160508T164007Z","urgency":0.583562}
 {"id":1,"description":"some description","entry":"20150619T165438Z","modified":"20160327T164007Z","project":"someproject","status":"waiting","tags":["some","tags","are","here"],"uuid":"8ca953d5-18b4-4eb9-bd56-18f2e5b752f0","wait":"20160508T164007Z","urgency":0.583562}"#;
diff --git a/src/lib.rs b/src/lib.rs
index 5bacf06..8006038 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -41,7 +41,7 @@
     unused_must_use,
     unused_mut,
     unused_qualifications,
-    while_true,
+    while_true
 )]
 
 extern crate chrono;
@@ -69,6 +69,6 @@ pub mod project;
 pub mod status;
 pub mod tag;
 pub mod task;
+pub mod tw;
 pub mod uda;
 pub mod urgency;
-pub mod tw;
diff --git a/src/status.rs b/src/status.rs
index a00201f..6b4b660 100644
--- a/src/status.rs
+++ b/src/status.rs
@@ -6,7 +6,7 @@
 
 //! Module containing `TaskStatus` type and trait impls
 
-use std::fmt::{Display, Formatter, Error as FmtError};
+use std::fmt::{Display, Error as FmtError, Formatter};
 
 /// Enum for status taskwarrior supports.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
diff --git a/src/task.rs b/src/task.rs
index fd7e708..2268fed 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -6,23 +6,23 @@
 
 //! Module containing `Task` type as well as trait implementations
 
-use std::result::Result as RResult;
 use std::fmt;
+use std::result::Result as RResult;
 
-use serde::{Serialize, Serializer};
+use chrono::Utc;
+use serde::de::{Error, MapAccess, Visitor};
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Deserializer};
-use serde::de::{Visitor, Error, MapAccess};
+use serde::{Serialize, Serializer};
 use uuid::Uuid;
-use chrono::Utc;
 
+use annotation::Annotation;
+use date::Date;
 use priority::TaskPriority;
-use status::TaskStatus;
 use project::Project;
+use status::TaskStatus;
 use tag::Tag;
-use date::Date;
-use annotation::Annotation;
-use uda::{UDA, UDAName, UDAValue};
+use uda::{UDAName, UDAValue, UDA};
 use urgency::Urgency;
 
 /// Task type
@@ -556,57 +556,57 @@ impl Serialize for Task {
         state.serialize_entry("entry", &self.entry)?;
         state.serialize_entry("description", &self.description)?;
 
-        self.annotations.as_ref().map(|v| {
-            state.serialize_entry("annotations", v)
-        });
+        self.annotations
+            .as_ref()
+            .map(|v| state.serialize_entry("annotations", v));
         self.tags.as_ref().map(|v| state.serialize_entry("tags", v));
         self.id.as_ref().map(|v| state.serialize_entry("id", v));
-        self.recur.as_ref().map(
-            |ref v| state.serialize_entry("recur", v),
-        );
+        self.recur
+            .as_ref()
+            .map(|ref v| state.serialize_entry("recur", v));
         self.depends.as_ref().map(|ref v| {
             let v: Vec<String> = v.iter().map(Uuid::to_string).collect();
             state.serialize_entry("depends", &v.join(","))
         });
-        self.due.as_ref().map(
-            |ref v| state.serialize_entry("due", v),
-        );
-        self.end.as_ref().map(
-            |ref v| state.serialize_entry("end", v),
-        );
-        self.imask.as_ref().map(
-            |ref v| state.serialize_entry("imask", v),
-        );
-        self.mask.as_ref().map(
-            |ref v| state.serialize_entry("mask", v),
-        );
-        self.modified.as_ref().map(|ref v| {
-            state.serialize_entry("modified", v)
-        });
-        self.parent.as_ref().map(|ref v| {
-            state.serialize_entry("parent", v)
-        });
-        self.priority.as_ref().map(|ref v| {
-            state.serialize_entry("priority", v)
-        });
-        self.project.as_ref().map(|ref v| {
-            state.serialize_entry("project", v)
-        });
-        self.scheduled.as_ref().map(|ref v| {
-            state.serialize_entry("scheduled", v)
-        });
-        self.start.as_ref().map(
-            |ref v| state.serialize_entry("start", v),
-        );
-        self.until.as_ref().map(
-            |ref v| state.serialize_entry("until", v),
-        );
-        self.wait.as_ref().map(
-            |ref v| state.serialize_entry("wait", v),
-        );
-        self.urgency.as_ref().map(
-            |ref v| state.serialize_entry("urgency", v),
-        );
+        self.due
+            .as_ref()
+            .map(|ref v| state.serialize_entry("due", v));
+        self.end
+            .as_ref()
+            .map(|ref v| state.serialize_entry("end", v));
+        self.imask
+            .as_ref()
+            .map(|ref v| state.serialize_entry("imask", v));
+        self.mask
+            .as_ref()
+            .map(|ref v| state.serialize_entry("mask", v));
+        self.modified
+            .as_ref()
+            .map(|ref v| state.serialize_entry("modified", v));
+        self.parent
+            .as_ref()
+            .map(|ref v| state.serialize_entry("parent", v));
+        self.priority
+            .as_ref()
+            .map(|ref v| state.serialize_entry("priority", v));
+        self.project
+            .as_ref()
+            .map(|ref v| state.serialize_entry("project", v));
+        self.scheduled
+            .as_ref()
+            .map(|ref v| state.serialize_entry("scheduled", v));
+        self.start
+            .as_ref()
+            .map(|ref v| state.serialize_entry("start", v));
+        self.until
+            .as_ref()
+            .map(|ref v| state.serialize_entry("until", v));
+        self.wait
+            .as_ref()
+            .map(|ref v| state.serialize_entry("wait", v));
+        self.urgency
+            .as_ref()
+            .map(|ref v| state.serialize_entry("urgency", v));
 
         for (key, value) in self.uda().iter() {
             state.serialize_entry(key, value)?;
@@ -627,7 +627,6 @@ impl<'de> Deserialize<'de> for Task {
             "uuid",
             "entry",
             "description",
-
             "annotations",
             "depends",
             "due",
@@ -807,7 +806,6 @@ impl<'de> Visitor<'de> for TaskDeserializeVisitor {
             uuid,
             entry,
             description,
-
             annotations,
             depends,
             due,
@@ -834,16 +832,16 @@ impl<'de> Visitor<'de> for TaskDeserializeVisitor {
 
 #[cfg(test)]
 mod test {
+    use annotation::Annotation;
     use date::Date;
     use date::TASKWARRIOR_DATETIME_TEMPLATE;
     use status::TaskStatus;
     use task::Task;
-    use annotation::Annotation;
     use uda::UDAValue;
 
-    use uuid::Uuid;
     use chrono::NaiveDateTime;
     use serde_json;
+    use uuid::Uuid;
 
     fn mklogger() {
         let _ = env_logger::init();
@@ -932,9 +930,7 @@ mod test {
 
         if let Some(tags) = task.tags() {
             for tag in tags {
-                let any_tag = ["some", "tags", "are", "here"].iter().any(
-                    |t| tag == *t,
-                );
+                let any_tag = ["some", "tags", "are", "here"].iter().any(|t| tag == *t);
                 assert!(any_tag, "Tag {} missing", tag);
             }
         } else {
@@ -960,9 +956,11 @@ mod test {
         assert!(back.contains("here"));
         assert!(back.contains("uuid"));
         assert!(back.contains("8ca953d5-18b4-4eb9-bd56-18f2e5b752f0"));
-        assert!(back.contains(
-            "8ca953d5-18b4-4eb9-bd56-18f2e5b752f0,5a04bb1e-3f4b-49fb-b9ba-44407ca223b5",
-        ));
+        assert!(
+            back.contains(
+                "8ca953d5-18b4-4eb9-bd56-18f2e5b752f0,5a04bb1e-3f4b-49fb-b9ba-44407ca223b5",
+            )
+        );
     }
 
     #[test]
@@ -992,15 +990,14 @@ mod test {
 
         assert!(task.urgency() == Some(&-5.0));
 
-        let all_annotations =
-            vec![
-                Annotation::new(mkdate("20160423T125911Z"), String::from("An Annotation")),
-                Annotation::new(
-                    mkdate("20160423T125926Z"),
-                    String::from("Another Annotation")
-                ),
-                Annotation::new(mkdate("20160422T125942Z"), String::from("A Third Anno")),
-            ];
+        let all_annotations = vec![
+            Annotation::new(mkdate("20160423T125911Z"), String::from("An Annotation")),
+            Annotation::new(
+                mkdate("20160423T125926Z"),
+                String::from("Another Annotation"),
+            ),
+            Annotation::new(mkdate("20160422T125942Z"), String::from("A Third Anno")),
+        ];
 
         if let Some(annotations) = task.annotations() {
             for annotation in annotations {
@@ -1133,7 +1130,7 @@ mod test {
     #[test]
     fn test_builder_extensive() {
         use task::TaskBuilder;
-        use uda::{UDA, UDAValue};
+        use uda::{UDAValue, UDA};
         let mut uda = UDA::new();
         uda.insert(
             "test_str_uda".into(),
@@ -1173,12 +1170,10 @@ mod test {
     #[test]
     fn test_builder_defaults() {
         use task::TaskBuilder;
-        assert!(
-            TaskBuilder::default()
-                .description("Nice Task")
-                .build()
-                .is_ok()
-        );
+        assert!(TaskBuilder::default()
+            .description("Nice Task")
+            .build()
+            .is_ok());
     }
 
     #[test]
@@ -1186,5 +1181,4 @@ mod test {
         use task::TaskBuilder;
         assert!(TaskBuilder::default().build().is_err());
     }
-
 }
diff --git a/src/tw.rs b/src/tw.rs
index f48955c..38e7e06 100644
--- a/src/tw.rs
+++ b/src/tw.rs
@@ -4,21 +4,20 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 //
 
-
 //! This module offers functions to interact with taskwarrior. This will expect the `task` binary
 //! in your path. This will always call task and never interact with your `.task` directory itself.
 //! (This is in accordance with the taskwarrior api guide lines.)
 
 use error::ErrorKind as EK;
-use task::Task;
-use std::process::{Command, Stdio, Child};
+use import::import;
 use std::io::Write;
 use std::iter::once;
-use import::import;
+use std::process::{Child, Command, Stdio};
+use task::Task;
 
-use serde_json;
 use failure::Fallible as Result;
 use failure::ResultExt;
+use serde_json;
 
 /// This will give you all tasks which match the given query in the taskwarrior query syntax.
 /// This is not sanitized. Never get the query string from an untrusted user.
diff --git a/src/uda.rs b/src/uda.rs
index 8f3f2ba..7f4d4d1 100644
--- a/src/uda.rs
+++ b/src/uda.rs
@@ -1,15 +1,15 @@
 //! Module containing the types for User Defined Attributes (UDA)
 
 use std::collections::BTreeMap;
-use std::result::Result as RResult;
 use std::fmt;
+use std::result::Result as RResult;
 
-use serde::Serialize;
-use serde::Serializer;
+use serde::de;
+use serde::de::Visitor;
 use serde::Deserialize;
 use serde::Deserializer;
-use serde::de::Visitor;
-use serde::de;
+use serde::Serialize;
+use serde::Serializer;
 
 /// The name of a UDA is just a string.
 pub type UDAName = String;