*: Run rustfmt

examples/single_mem_node/main.rs

@@ -13,21 +13,25 @@
 
 extern crate raft;
 
+use std::collections::HashMap;
 use std::sync::mpsc::{self, RecvTimeoutError};
-use std::time::{Duration, Instant};
 use std::thread;
-use std::collections::HashMap;
+use std::time::{Duration, Instant};
 
 use raft::prelude::*;
 use raft::storage::MemStorage;
 
 type ProposeCallback = Box<Fn() + Send>;
 
 enum Msg {
-    Propose { id: u8, cb: ProposeCallback },
+    Propose {
+        id: u8,
+        cb: ProposeCallback,
+    },
     // Here we don't use Raft Message, so use dead_code to
     // avoid the compiler warning.
-    #[allow(dead_code)] Raft(Message),
+    #[allow(dead_code)]
+    Raft(Message),
 }
 
 // A simple example about how to use the Raft library in Rust.

src/errors.rs

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{cmp, io, result};
 use std::error;
+use std::{cmp, io, result};
 
 use protobuf::ProtobufError;
 
@@ -110,8 +110,8 @@ pub type Result<T> = result::Result<T, Error>;
 
 #[cfg(test)]
 mod tests {
-    use std::io;
     use super::*;
+    use std::io;
 
     #[test]
     fn test_error_equal() {

src/lib.rs

@@ -38,27 +38,27 @@ extern crate quick_error;
 extern crate rand;
 
 pub mod eraftpb;
-mod raft_log;
-pub mod storage;
-mod raft;
-mod progress;
 mod errors;
 mod log_unstable;
-mod status;
+mod progress;
+mod raft;
+mod raft_log;
 pub mod raw_node;
 mod read_only;
+mod status;
+pub mod storage;
 pub mod util;
 
-pub use self::storage::{RaftState, Storage};
 pub use self::errors::{Error, Result, StorageError};
+pub use self::log_unstable::Unstable;
+pub use self::progress::{Inflights, Progress, ProgressSet, ProgressState};
 pub use self::raft::{quorum, vote_resp_msg_type, Config, Raft, SoftState, StateRole, INVALID_ID,
                      INVALID_INDEX};
 pub use self::raft_log::{RaftLog, NO_LIMIT};
 pub use self::raw_node::{is_empty_snap, Peer, RawNode, Ready, SnapshotStatus};
-pub use self::status::Status;
-pub use self::log_unstable::Unstable;
-pub use self::progress::{Inflights, Progress, ProgressSet, ProgressState};
 pub use self::read_only::{ReadOnlyOption, ReadState};
+pub use self::status::Status;
+pub use self::storage::{RaftState, Storage};
 
 pub mod prelude {
     //! A "prelude" for crates using the `raft` crate.

src/progress.rs

@@ -25,10 +25,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use fxhash::FxHashMap;
 use std::cmp;
-use std::iter::Chain;
 use std::collections::hash_map::{HashMap, Iter, IterMut};
-use fxhash::FxHashMap;
+use std::iter::Chain;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum ProgressState {

src/raft.rs

@@ -27,16 +27,16 @@
 
 use std::cmp;
 
-use rand::{self, Rng};
 use eraftpb::{Entry, EntryType, HardState, Message, MessageType, Snapshot};
 use fxhash::FxHashMap;
 use protobuf::repeated::RepeatedField;
+use rand::{self, Rng};
 
-use super::storage::Storage;
-use super::progress::{Inflights, Progress, ProgressSet, ProgressState};
 use super::errors::{Error, Result, StorageError};
+use super::progress::{Inflights, Progress, ProgressSet, ProgressState};
 use super::raft_log::{self, RaftLog};
 use super::read_only::{ReadOnly, ReadOnlyOption, ReadState};
+use super::storage::Storage;
 
 // CAMPAIGN_PRE_ELECTION represents the first phase of a normal election when
 // Config.pre_vote is true.

src/raft_log.rs

@@ -29,9 +29,9 @@ use std::cmp;
 
 use eraftpb::{Entry, Snapshot};
 
-use storage::Storage;
-use log_unstable::Unstable;
 use errors::{Error, Result, StorageError};
+use log_unstable::Unstable;
+use storage::Storage;
 use util;
 
 pub use util::NO_LIMIT;
@@ -430,11 +430,11 @@ impl<T: Storage> RaftLog<T> {
 mod test {
     use std::panic::{self, AssertUnwindSafe};
 
-    use raft_log::{self, RaftLog};
-    use storage::MemStorage;
     use eraftpb;
     use errors::{Error, StorageError};
     use protobuf;
+    use raft_log::{self, RaftLog};
+    use storage::MemStorage;
 
     fn new_raft_log(s: MemStorage) -> RaftLog<MemStorage> {
         RaftLog::new(s, String::from(""))

src/raw_node.rs

@@ -27,15 +27,15 @@
 
 use std::mem;
 
-use protobuf::{self, RepeatedField};
 use eraftpb::{ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message,
               MessageType, Snapshot};
+use protobuf::{self, RepeatedField};
 
 use super::errors::{Error, Result};
-use super::Storage;
 use super::raft::{Config, Raft, SoftState, INVALID_ID};
-use super::Status;
 use super::read_only::ReadState;
+use super::Status;
+use super::Storage;
 
 #[derive(Debug, Default)]
 pub struct Peer {
@@ -454,8 +454,8 @@ impl<T: Storage> RawNode<T> {
 
 #[cfg(test)]
 mod test {
-    use eraftpb::MessageType;
     use super::is_local_msg;
+    use eraftpb::MessageType;
 
     #[test]
     fn test_is_local_msg() {

src/status.rs

@@ -28,9 +28,9 @@
 use eraftpb::HardState;
 use fxhash::FxHashMap;
 
+use progress::Progress;
 use raft::{Raft, SoftState, StateRole};
 use storage::Storage;
-use progress::Progress;
 
 #[derive(Default)]
 pub struct Status {

src/storage.rs

@@ -303,8 +303,8 @@ impl Storage for MemStorage {
 
 #[cfg(test)]
 mod test {
-    use protobuf;
     use eraftpb::{ConfState, Entry, Snapshot};
+    use protobuf;
 
     use errors::{Error as RaftError, StorageError};
     use storage::{MemStorage, Storage};

tests/cases/mod.rs

@@ -12,7 +12,7 @@
 // limitations under the License.
 
 mod test_raft;
-mod test_raft_snap;
-mod test_raft_paper;
 mod test_raft_flow_control;
+mod test_raft_paper;
+mod test_raft_snap;
 mod test_raw_node;

tests/cases/test_raft.rs

@@ -25,19 +25,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::cmp;
 use std::collections::HashMap;
 use std::ops::Deref;
 use std::ops::DerefMut;
-use std::cmp;
 use std::panic::{self, AssertUnwindSafe};
 
 use protobuf::{self, RepeatedField};
 use raft::eraftpb::{ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message,
                     MessageType, Snapshot};
 use rand;
 
-use raft::*;
 use raft::storage::MemStorage;
+use raft::*;
 
 pub fn ltoa(raft_log: &RaftLog<MemStorage>) -> String {
     let mut s = format!("committed: {}\n", raft_log.committed);
@@ -897,34 +897,22 @@ fn test_vote_from_any_state_for_type(vt: MessageType) {
                 StateRole::Follower
             );
             assert_eq!(
-                r.term,
-                new_term,
+                r.term, new_term,
                 "{:?},{:?}, term {}, want {}",
-                vt,
-                state,
-                r.term,
-                new_term
+                vt, state, r.term, new_term
             );
             assert_eq!(r.vote, 2, "{:?},{:?}, vote {}, want 2", vt, state, r.vote);
         } else {
             // In a pre-vote, nothing changes.
             assert_eq!(
-                r.state,
-                state,
+                r.state, state,
                 "{:?},{:?}, state {:?}, want {:?}",
-                vt,
-                state,
-                r.state,
-                state
+                vt, state, r.state, state
             );
             assert_eq!(
-                r.term,
-                orig_term,
+                r.term, orig_term,
                 "{:?},{:?}, term {}, want {}",
-                vt,
-                state,
-                r.term,
-                orig_term
+                vt, state, r.term, orig_term
             );
             // If state == Follower or PreCandidate, r hasn't voted yet.
             // In Candidate or Leader, it's voted for itself.
@@ -2030,11 +2018,9 @@ fn test_candidate_reset_term(message_type: MessageType) {
 
     // follower c term is reset with leader's
     assert_eq!(
-        nt.peers[&3].term,
-        nt.peers[&1].term,
+        nt.peers[&3].term, nt.peers[&1].term,
         "follower term expected same term as leader's {}, got {}",
-        nt.peers[&1].term,
-        nt.peers[&3].term,
+        nt.peers[&1].term, nt.peers[&3].term,
     )
 }
 

tests/cases/test_raft_paper.rs

@@ -26,10 +26,10 @@
 // limitations under the License.
 
 use super::test_raft::*;
+use protobuf::RepeatedField;
 use raft::eraftpb::*;
-use raft::*;
 use raft::storage::MemStorage;
-use protobuf::RepeatedField;
+use raft::*;
 
 pub fn hard_state(t: u64, c: u64, v: u64) -> HardState {
     let mut hs = HardState::new();

tests/cases/test_raw_node.rs

@@ -25,14 +25,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::cell::RefCell;
-use std::rc::Rc;
-use raft::eraftpb::*;
-use protobuf::{self, ProtobufEnum};
-use raft::*;
-use raft::storage::MemStorage;
 use super::test_raft::*;
 use super::test_raft_paper::*;
+use protobuf::{self, ProtobufEnum};
+use raft::eraftpb::*;
+use raft::storage::MemStorage;
+use raft::*;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 fn new_peer(id: u64) -> Peer {
     Peer {