style(rustfmt): fmt

7 files changed, 42 insertions, 34 deletions

diff --git a/src/display/ui.rs b/src/display/ui.rs
index 30d36d0..dae50aa 100644
--- a/src/display/ui.rs
+++ b/src/display/ui.rs
@@ -28,10 +28,10 @@ impl fmt::Display for DisplayBandwidth {
     }
 }
 
-fn display_ip_or_host (ip: &Ipv4Addr, ip_to_host: &HashMap<Ipv4Addr, String>) -> String {
+fn display_ip_or_host(ip: &Ipv4Addr, ip_to_host: &HashMap<Ipv4Addr, String>) -> String {
     match ip_to_host.get(ip) {
         Some(host) => host.clone(),
-        None => ip.to_string()
+        None => ip.to_string(),
     }
 }
 
@@ -95,7 +95,12 @@ fn render_process_table(state: &UIState, frame: &mut Frame<impl Backend>, rect:
     table.render(frame, rect);
 }
 
-fn render_connections_table(state: &UIState, frame: &mut Frame<impl Backend>, rect: Rect, ip_to_host: &HashMap<Ipv4Addr, String>) {
+fn render_connections_table(
+    state: &UIState,
+    frame: &mut Frame<impl Backend>,
+    rect: Rect,
+    ip_to_host: &HashMap<Ipv4Addr, String>,
+) {
     let rows = state
         .connections
         .iter()
@@ -123,7 +128,12 @@ fn render_connections_table(state: &UIState, frame: &mut Frame<impl Backend>, re
     table.render(frame, rect);
 }
 
-fn render_remote_ip_table(state: &UIState, frame: &mut Frame<impl Backend>, rect: Rect, ip_to_host: &HashMap<Ipv4Addr, String>) {
+fn render_remote_ip_table(
+    state: &UIState,
+    frame: &mut Frame<impl Backend>,
+    rect: Rect,
+    ip_to_host: &HashMap<Ipv4Addr, String>,
+) {
     let rows = state
         .remote_ips
         .iter()
@@ -145,17 +155,19 @@ fn render_remote_ip_table(state: &UIState, frame: &mut Frame<impl Backend>, rect
 }
 
 pub struct Ui<B>
-where B: Backend
+where
+    B: Backend,
 {
     terminal: Terminal<B>,
     state: UIState,
     ip_to_host: HashMap<Ipv4Addr, String>,
 }
 
-impl <B>Ui<B>
-where B: Backend
+impl<B> Ui<B>
+where
+    B: Backend,
 {
-    pub fn new (terminal_backend: B) -> Self {
+    pub fn new(terminal_backend: B) -> Self {
         let mut terminal = Terminal::new(terminal_backend).unwrap();
         terminal.clear().unwrap();
         terminal.hide_cursor().unwrap();
@@ -165,7 +177,7 @@ where B: Backend
             ip_to_host: Default::default(),
         }
     }
-    pub fn draw (&mut self) {
+    pub fn draw(&mut self) {
         let state = &self.state;
         let ip_to_host = &self.ip_to_host;
         self.terminal
@@ -188,7 +200,8 @@ where B: Backend
         self.state = UIState::new(connections_to_procs, utilization);
         self.ip_to_host = ip_to_host;
     }
-    pub fn end(&mut self) { // TODO: destroy?
+    pub fn end(&mut self) {
+        // TODO: destroy?
         self.terminal.clear().unwrap();
         self.terminal.show_cursor().unwrap();
     }
diff --git a/src/display/ui_state.rs b/src/display/ui_state.rs
index 3469518..440260d 100644
--- a/src/display/ui_state.rs
+++ b/src/display/ui_state.rs
@@ -59,9 +59,7 @@ impl UIState {
             if let Some(connection_bandwidth_utilization) =
                 network_utilization.connections.get(&connection)
             {
-                let data_for_remote_ip = remote_ips
-                    .entry(connection.remote_socket.ip)
-                    .or_default();
+                let data_for_remote_ip = remote_ips.entry(connection.remote_socket.ip).or_default();
                 let connection_data = connections.entry(connection).or_default();
                 let data_for_process = processes.entry(process_name.clone()).or_default();
 
diff --git a/src/main.rs b/src/main.rs
index 0d44a61..eb92eef 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,14 +7,14 @@ mod tests;
 use display::Ui;
 use network::{Connection, DnsQueue, Sniffer, Utilization};
 
-use ::std::net:: IpAddr;
+use ::std::net::IpAddr;
 
 use ::pnet::datalink::{DataLinkReceiver, NetworkInterface};
 use ::std::collections::HashMap;
 use ::std::sync::atomic::{AtomicBool, Ordering};
 use ::std::sync::{Arc, Mutex};
-use ::std::{thread, time};
 use ::std::thread::park_timeout;
+use ::std::{thread, time};
 use ::termion::event::{Event, Key};
 use ::tui::backend::Backend;
 
@@ -37,7 +37,10 @@ fn main() {
         "Sorry, no implementations for platforms other than linux yet :( - PRs welcome!"
     );
 
-    use os::{get_datalink_channel, get_interface, get_open_sockets, lookup_addr, receive_winch, KeyboardEvents};
+    use os::{
+        get_datalink_channel, get_interface, get_open_sockets, lookup_addr, receive_winch,
+        KeyboardEvents,
+    };
 
     let opt = Opt::from_args();
     let stdout = io::stdout().into_raw_mode().unwrap();
@@ -127,9 +130,7 @@ where
         move || {
             while running.load(Ordering::Acquire) {
                 let connections_to_procs = get_open_sockets();
-                let ip_to_host = {
-                    ip_to_host.lock().unwrap().clone()
-                };
+                let ip_to_host = { ip_to_host.lock().unwrap().clone() };
                 let utilization = {
                     let mut network_utilization = network_utilization.lock().unwrap();
                     network_utilization.clone_and_reset()
@@ -165,7 +166,6 @@ where
         }
     });
 
-
     let sniffing_handler = thread::spawn(move || {
         while running.load(Ordering::Acquire) {
             if let Some(segment) = sniffer.next() {
diff --git a/src/network/dns_queue.rs b/src/network/dns_queue.rs
index f504f81..f5c1ddf 100644
--- a/src/network/dns_queue.rs
+++ b/src/network/dns_queue.rs
@@ -1,6 +1,6 @@
+use ::std::collections::HashMap;
 use ::std::net::Ipv4Addr;
 use ::std::sync::{Condvar, Mutex};
-use ::std::collections::HashMap;
 
 use crate::network::Connection;
 
@@ -32,7 +32,7 @@ impl DnsQueue {
             if !ip_to_host.contains_key(&connection.remote_socket.ip) {
                 queue.push(Some(connection.remote_socket.ip.clone()));
             }
-        };
+        }
         self.cvar.notify_all();
     }
     pub fn wait_for_job(&self) -> Option<Ipv4Addr> {
diff --git a/src/os/linux.rs b/src/os/linux.rs
index 7ac5e9f..39bb5c0 100644
--- a/src/os/linux.rs
+++ b/src/os/linux.rs
@@ -1,6 +1,6 @@
 use ::pnet::datalink::Channel::Ethernet;
 use ::pnet::datalink::DataLinkReceiver;
-use ::pnet::datalink::{self, NetworkInterface, Config};
+use ::pnet::datalink::{self, Config, NetworkInterface};
 use ::std::io::stdin;
 use ::termion::event::Event;
 use ::termion::input::TermRead;
@@ -92,7 +92,6 @@ pub fn lookup_addr(ip: &IpAddr) -> Option<String> {
 }
 
 pub fn receive_winch(winch: &Arc<AtomicBool>) {
-    ::signal_hook::flag::register(
-        signal_hook::SIGWINCH, winch.clone()
-    ).expect("Failed to register SIGWINCH");
+    ::signal_hook::flag::register(signal_hook::SIGWINCH, winch.clone())
+        .expect("Failed to register SIGWINCH");
 }
diff --git a/src/tests/fakes/fake_input.rs b/src/tests/fakes/fake_input.rs
index b854c3b..ac02c36 100644
--- a/src/tests/fakes/fake_input.rs
+++ b/src/tests/fakes/fake_input.rs
@@ -6,8 +6,8 @@ use ::std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use ::std::{thread, time};
 use ::termion::event::Event;
 
-use ::std::sync::Arc;
 use ::std::sync::atomic::{AtomicBool, Ordering};
+use ::std::sync::Arc;
 
 use crate::network::{Connection, Protocol};
 
@@ -155,9 +155,7 @@ pub fn create_fake_lookup_addr(
     })
 }
 
-pub fn create_fake_receive_winch(
-    should_send_winch_event: bool
-) -> Box<Fn(&Arc<AtomicBool>)> {
+pub fn create_fake_receive_winch(should_send_winch_event: bool) -> Box<Fn(&Arc<AtomicBool>)> {
     Box::new(move |winch| {
         if should_send_winch_event {
             thread::sleep(time::Duration::from_secs(1));
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 1ee3af9..853a056 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -2,8 +2,8 @@ mod fakes;
 
 use fakes::TerminalEvent::*;
 use fakes::{
-    create_fake_lookup_addr, get_interface, get_open_sockets, KeyboardEvents, NetworkFrames,
-    TestBackend, create_fake_receive_winch
+    create_fake_lookup_addr, create_fake_receive_winch, get_interface, get_open_sockets,
+    KeyboardEvents, NetworkFrames, TestBackend,
 };
 
 use ::insta::assert_snapshot;
@@ -817,7 +817,7 @@ fn traffic_with_host_names() {
 }
 
 #[test]
-fn traffic_with_winch_event () {
+fn traffic_with_winch_event() {
     let keyboard_events = Box::new(KeyboardEvents::new(vec![
         None, // sleep
         None, // sleep
@@ -853,7 +853,7 @@ fn traffic_with_winch_event () {
     let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();
 
     let expected_terminal_events = vec![
-        Clear, HideCursor, Draw, Flush, Draw, Flush, Draw, Flush, Clear, ShowCursor
+        Clear, HideCursor, Draw, Flush, Draw, Flush, Draw, Flush, Clear, ShowCursor,
     ];
     assert_eq!(&terminal_events_mirror[..], &expected_terminal_events[..]);