Reformat with new rustfmt settings

3 files changed, 37 insertions, 26 deletions

diff --git a/talpid_core/src/net.rs b/talpid_core/src/net.rs
index 3701ae641e..f5f40688a7 100644
--- a/talpid_core/src/net.rs
+++ b/talpid_core/src/net.rs
@@ -56,9 +56,9 @@ impl RemoteAddr {
 
     fn from_domain_str(s: &str) -> Result<Self> {
         let (address, port_str) = Self::split_at_last_colon(s)?;
-        let port = u16::from_str(port_str).chain_err(|| {
-            ErrorKind::AddrParse(format!("Invalid port: \"{}\"", port_str))
-        })?;
+        let port =
+            u16::from_str(port_str)
+                .chain_err(|| ErrorKind::AddrParse(format!("Invalid port: \"{}\"", port_str)),)?;
         if address.is_empty() || address.contains(':') {
             let msg = format!("Invalid IP or domain: \"{}\"", address);
             bail!(ErrorKind::AddrParse(msg));
diff --git a/talpid_core/src/process/monitor.rs b/talpid_core/src/process/monitor.rs
index 3a6f9fb65f..c4e8b402d4 100644
--- a/talpid_core/src/process/monitor.rs
+++ b/talpid_core/src/process/monitor.rs
@@ -1,5 +1,5 @@
 use std::io;
-use std::process::{ChildStdout, ChildStderr};
+use std::process::{ChildStderr, ChildStdout};
 use std::sync::{Arc, Mutex};
 use std::thread;
 
@@ -85,10 +85,12 @@ impl<S: ChildSpawner> ChildMonitor<S> {
             let mut child = self.spawner.spawn().chain_err(|| ErrorKind::Spawn)?;
             let io = (child.stdout(), child.stderr());
             let thread_handle = self.spawn_monitor(child.clone(), listener);
-            *state_lock = State::Running(RunningState {
-                child: child,
-                thread_handle: Some(thread_handle),
-            });
+            *state_lock = State::Running(
+                RunningState {
+                    child: child,
+                    thread_handle: Some(thread_handle),
+                },
+            );
             Ok(io)
         } else {
             bail!(ErrorKind::InvalidState);
@@ -99,14 +101,16 @@ impl<S: ChildSpawner> ChildMonitor<S> {
         where L: FnMut(bool) + Send + 'static
     {
         let state_mutex = self.state.clone();
-        thread::spawn(move || {
-            let success = child.wait().unwrap_or(false);
-            {
-                let mut state_lock = state_mutex.lock().unwrap();
-                *state_lock = State::Stopped;
-            }
-            listener(success);
-        })
+        thread::spawn(
+            move || {
+                let success = child.wait().unwrap_or(false);
+                {
+                    let mut state_lock = state_mutex.lock().unwrap();
+                    *state_lock = State::Stopped;
+                }
+                listener(success);
+            },
+        )
     }
 
     /// Sends a kill signal to the child process.
@@ -143,7 +147,7 @@ impl<S: ChildSpawner> Drop for ChildMonitor<S> {
 mod child_monitor_tests {
     use super::*;
     use std::io;
-    use std::process::{ChildStdout, ChildStderr};
+    use std::process::{ChildStderr, ChildStdout};
     use std::sync::{Arc, Mutex};
     use std::sync::mpsc;
     use std::thread;
@@ -209,7 +213,7 @@ mod child_monitor_tests {
         fn spawn(&mut self) -> io::Result<MockChild> {
             self.spawn_result
                 .clone()
-                .ok_or(io::Error::new(io::ErrorKind::Other, "Mocking a failed process spawn"))
+                .ok_or(io::Error::new(io::ErrorKind::Other, "Mocking a failed process spawn"),)
         }
     }
 
diff --git a/talpid_core/src/process/openvpn.rs b/talpid_core/src/process/openvpn.rs
index e002d2b9c3..231898c6f8 100644
--- a/talpid_core/src/process/openvpn.rs
+++ b/talpid_core/src/process/openvpn.rs
@@ -1,18 +1,18 @@
 extern crate openvpn_ffi;
 
-use super::monitor::{ChildSpawner, ChildMonitor};
+use super::monitor::{ChildMonitor, ChildSpawner};
 
-use clonablechild::{ClonableChild, ChildExt};
+use clonablechild::{ChildExt, ClonableChild};
 
 use net::{RemoteAddr, ToRemoteAddrs};
 
 use std::collections::HashMap;
-use std::ffi::{OsString, OsStr};
+use std::ffi::{OsStr, OsString};
 use std::fmt;
 use std::io;
 use std::ops::DerefMut;
 use std::path::{Path, PathBuf};
-use std::process::{Command, Child, Stdio, ChildStdout, ChildStderr};
+use std::process::{Child, ChildStderr, ChildStdout, Command, Stdio};
 use std::sync::{Arc, Mutex};
 
 use talpid_ipc;
@@ -90,7 +90,8 @@ impl OpenVpnCommand {
 
     fn create_command(&self) -> Command {
         let mut command = Command::new(&self.openvpn_bin);
-        command.stdin(Stdio::null())
+        command
+            .stdin(Stdio::null())
             .stdout(self.get_output_pipe_policy())
             .stderr(self.get_output_pipe_policy());
         command
@@ -197,11 +198,14 @@ impl OpenVpnMonitor {
     fn start_plugin_listener<L>(&mut self, shared_listener: Arc<Mutex<L>>) -> Result<()>
         where L: FnMut(OpenVpnEvent) + Send + 'static
     {
-        let server_id = talpid_ipc::start_new_server(move |msg| {
+        let server_id = talpid_ipc::start_new_server(
+            move |msg| {
                 let chained_msg = msg.chain_err(|| ErrorKind::PluginCommunicationError);
                 let mut listener = shared_listener.lock().unwrap();
                 (listener.deref_mut())(OpenVpnEvent::PluginEvent(chained_msg));
-            }).chain_err(|| ErrorKind::PluginCommunicationError)?;
+            },
+        )
+                .chain_err(|| ErrorKind::PluginCommunicationError)?;
         self.command.plugin(&self.plugin_path, vec![server_id]);
         Ok(())
     }
@@ -251,7 +255,10 @@ mod openvpn_command_tests {
 
     #[test]
     fn passes_two_remotes() {
-        let remotes = vec![RemoteAddr::new("127.0.0.1", 998), RemoteAddr::new("fe80::1", 1337)];
+        let remotes = vec![
+            RemoteAddr::new("127.0.0.1", 998),
+            RemoteAddr::new("fe80::1", 1337),
+        ];
 
         let testee_args = OpenVpnCommand::new("").remotes(&remotes[..]).unwrap().get_arguments();