diff --git a/src/lib/be/mod.rs b/src/lib/be/mod.rs
index a54737254..0be684007 100644
--- a/src/lib/be/mod.rs
+++ b/src/lib/be/mod.rs
@@ -552,9 +552,7 @@ mod tests {
     use super::super::audit::AuditScope;
     use super::super::entry::{Entry, EntryInvalid, EntryNew};
     use super::super::filter::Filter;
-    use super::{
-        Backend, BackendError, BackendReadTransaction, BackendWriteTransaction,
-    };
+    use super::{Backend, BackendError, BackendReadTransaction, BackendWriteTransaction};
 
     macro_rules! run_test {
         ($test_fn:expr) => {{
diff --git a/src/lib/entry.rs b/src/lib/entry.rs
index 1bddce521..640497f60 100644
--- a/src/lib/entry.rs
+++ b/src/lib/entry.rs
@@ -2,7 +2,7 @@
 use super::proto_v1::Entry as ProtoEntry;
 use error::SchemaError;
 use filter::{Filter, FilterValid};
-use modify::{Modify, ModifyList, ModifyValid, ModifyInvalid};
+use modify::{Modify, ModifyInvalid, ModifyList, ModifyValid};
 use schema::{SchemaAttribute, SchemaClass, SchemaReadTransaction};
 use std::collections::btree_map::{Iter as BTreeIter, IterMut as BTreeIterMut};
 use std::collections::BTreeMap;
@@ -645,7 +645,10 @@ where
     }
 
     // Should this be schemaless, relying on checks of the modlist, and the entry validate after?
-    pub fn apply_modlist(&self, modlist: &ModifyList<ModifyValid>) -> Result<Entry<EntryInvalid, STATE>, ()> {
+    pub fn apply_modlist(
+        &self,
+        modlist: &ModifyList<ModifyValid>,
+    ) -> Result<Entry<EntryInvalid, STATE>, ()> {
         // Apply a modlist, generating a new entry that conforms to the changes.
         // This is effectively clone-and-transform
 
diff --git a/src/lib/event.rs b/src/lib/event.rs
index 9e0ad3025..eaa6cc50c 100644
--- a/src/lib/event.rs
+++ b/src/lib/event.rs
@@ -6,7 +6,7 @@ use super::proto_v1::{
 };
 use entry::{Entry, EntryCommitted, EntryInvalid, EntryNew, EntryValid};
 // use error::OperationError;
-use modify::{ModifyList, ModifyInvalid};
+use modify::{ModifyInvalid, ModifyList};
 
 use actix::prelude::*;
 
diff --git a/src/lib/modify.rs b/src/lib/modify.rs
index d60b07bcc..a4e0bf0a8 100644
--- a/src/lib/modify.rs
+++ b/src/lib/modify.rs
@@ -51,19 +51,18 @@ impl<'a> IntoIterator for &'a ModifyList<ModifyValid> {
     }
 }
 
-
 impl ModifyList<ModifyInvalid> {
     pub fn new() -> Self {
         ModifyList {
             valid: ModifyInvalid,
-            mods: Vec::new()
+            mods: Vec::new(),
         }
     }
 
     pub fn new_list(mods: Vec<Modify>) -> Self {
         ModifyList {
             valid: ModifyInvalid,
-            mods: mods
+            mods: mods,
         }
     }
 
@@ -79,50 +78,47 @@ impl ModifyList<ModifyInvalid> {
         }
     }
 
-    pub fn validate(&self,
+    pub fn validate(
+        &self,
         schema: &SchemaReadTransaction,
-        ) -> Result<ModifyList<ModifyValid>, SchemaError> {
-
+    ) -> Result<ModifyList<ModifyValid>, SchemaError> {
         let schema_attributes = schema.get_attributes();
         let schema_name = schema_attributes
             .get("name")
             .expect("Critical: Core schema corrupt or missing. To initiate a core transfer, please deposit substitute core in receptacle.");
 
-        let res: Result<Vec<Modify>, _> = (&self.mods).into_iter()
-            .map(|m| {
-                match m {
-                    Modify::Present(attr, value) => {
-                        let attr_norm = schema_name.normalise_value(&attr);
-                        match schema_attributes.get(&attr_norm) {
-                            Some(schema_a) => {
-                                let value_norm = schema_a.normalise_value(&value);
-                                schema_a
-                                    .validate_value(&value_norm)
-                                    .map(|_| Modify::Present(attr_norm, value_norm))
-                            }
-                            None => Err(SchemaError::InvalidAttribute),
+        let res: Result<Vec<Modify>, _> = (&self.mods)
+            .into_iter()
+            .map(|m| match m {
+                Modify::Present(attr, value) => {
+                    let attr_norm = schema_name.normalise_value(&attr);
+                    match schema_attributes.get(&attr_norm) {
+                        Some(schema_a) => {
+                            let value_norm = schema_a.normalise_value(&value);
+                            schema_a
+                                .validate_value(&value_norm)
+                                .map(|_| Modify::Present(attr_norm, value_norm))
                         }
+                        None => Err(SchemaError::InvalidAttribute),
                     }
-                    Modify::Removed(attr, value) => {
-                        let attr_norm = schema_name.normalise_value(&attr);
-                        match schema_attributes.get(&attr_norm) {
-                            Some(schema_a) => {
-                                let value_norm = schema_a.normalise_value(&value);
-                                schema_a
-                                    .validate_value(&value_norm)
-                                    .map(|_| Modify::Removed(attr_norm, value_norm))
-                            }
-                            None => Err(SchemaError::InvalidAttribute),
+                }
+                Modify::Removed(attr, value) => {
+                    let attr_norm = schema_name.normalise_value(&attr);
+                    match schema_attributes.get(&attr_norm) {
+                        Some(schema_a) => {
+                            let value_norm = schema_a.normalise_value(&value);
+                            schema_a
+                                .validate_value(&value_norm)
+                                .map(|_| Modify::Removed(attr_norm, value_norm))
                         }
+                        None => Err(SchemaError::InvalidAttribute),
                     }
-                    Modify::Purged(attr) => {
-                        let attr_norm = schema_name.normalise_value(&attr);
-                        match schema_attributes.get(&attr_norm) {
-                            Some(_attr_name) => {
-                                Ok(Modify::Purged(attr_norm))
-                            }
-                            None => Err(SchemaError::InvalidAttribute),
-                        }
+                }
+                Modify::Purged(attr) => {
+                    let attr_norm = schema_name.normalise_value(&attr);
+                    match schema_attributes.get(&attr_norm) {
+                        Some(_attr_name) => Ok(Modify::Purged(attr_norm)),
+                        None => Err(SchemaError::InvalidAttribute),
                     }
                 }
             })
@@ -146,7 +142,7 @@ impl ModifyList<ModifyValid> {
     pub unsafe fn new_valid_list(mods: Vec<Modify>) -> Self {
         ModifyList {
             valid: ModifyValid,
-            mods: mods
+            mods: mods,
         }
     }
 }
diff --git a/src/lib/server.rs b/src/lib/server.rs
index a8dbfccbb..c5e2504b3 100644
--- a/src/lib/server.rs
+++ b/src/lib/server.rs
@@ -13,7 +13,7 @@ use entry::{Entry, EntryCommitted, EntryInvalid, EntryNew, EntryValid};
 use error::{OperationError, SchemaError};
 use event::{CreateEvent, DeleteEvent, ExistsEvent, ModifyEvent, ReviveRecycledEvent, SearchEvent};
 use filter::{Filter, FilterInvalid};
-use modify::{Modify, ModifyList, ModifyInvalid};
+use modify::{Modify, ModifyInvalid, ModifyList};
 use plugins::Plugins;
 use schema::{Schema, SchemaReadTransaction, SchemaTransaction, SchemaWriteTransaction};
 
@@ -979,7 +979,6 @@ mod tests {
     */
     use std::sync::Arc;
 
-
     use super::super::audit::AuditScope;
     use super::super::be::Backend;
     use super::super::entry::{Entry, EntryInvalid, EntryNew};
@@ -993,13 +992,10 @@ mod tests {
     use super::super::proto_v1::Modify as ProtoModify;
     use super::super::proto_v1::ModifyList as ProtoModifyList;
     use super::super::proto_v1::{
-        DeleteRequest, ModifyRequest, ReviveRecycledRequest, SearchRecycledRequest,
-        SearchRequest,
+        DeleteRequest, ModifyRequest, ReviveRecycledRequest, SearchRecycledRequest, SearchRequest,
     };
     use super::super::schema::Schema;
-    use super::super::server::{
-        QueryServer, QueryServerReadTransaction
-    };
+    use super::super::server::{QueryServer, QueryServerReadTransaction};
 
     macro_rules! run_test {
         ($test_fn:expr) => {{