rustfmt

.rustfmt.toml

@@ -0,0 +1,2 @@
+use_try_shorthand = true
+error_on_line_overflow = false

examples/autobahn-client.rs

@@ -1,54 +1,47 @@
 /// WebSocket client used for testing against the Autobahn Test Suite
-
 extern crate ws;
 
 use std::rc::Rc;
 use std::cell::Cell;
 use ws::{connect, CloseCode, Message, Result};
 
-#[cfg(feature="permessage-deflate")]
+#[cfg(feature = "permessage-deflate")]
 use ws::deflate::DeflateHandler;
 
 const AGENT: &'static str = "WS-RS";
 
-#[cfg(not(feature="permessage-deflate"))]
-fn main () {
-
+#[cfg(not(feature = "permessage-deflate"))]
+fn main() {
     let total = get_case_count().unwrap();
     let mut case_id = 1;
 
-
     while case_id <= total {
+        let case_url = format!(
+            "ws://127.0.0.1:9001/runCase?case={}&agent={}",
+            case_id, AGENT
+        );
 
-        let case_url = format!("ws://127.0.0.1:9001/runCase?case={}&agent={}", case_id, AGENT);
-
-        connect(case_url, |out| {
-            move |msg| {
-                out.send(msg)
-            }
-        }).unwrap();
+        connect(case_url, |out| move |msg| out.send(msg)).unwrap();
 
         case_id += 1
     }
 
     update_reports().unwrap();
 }
 
-#[cfg(feature="permessage-deflate")]
-fn main () {
-
+#[cfg(feature = "permessage-deflate")]
+fn main() {
     let total = get_case_count().unwrap();
     let mut case_id = 1;
 
-
     while case_id <= total {
-
-        let case_url = format!("ws://127.0.0.1:9001/runCase?case={}&agent={}", case_id, AGENT);
+        let case_url = format!(
+            "ws://127.0.0.1:9001/runCase?case={}&agent={}",
+            case_id, AGENT
+        );
 
         connect(case_url, |out| {
-            DeflateHandler::new(move |msg| {
-                out.send(msg)
-            })
+            DeflateHandler::new(move |msg| out.send(msg))
         }).unwrap();
 
         case_id += 1
@@ -58,34 +51,26 @@ fn main () {
 }
 
 fn get_case_count() -> Result<u32> {
-
     // sadly we need to use a Cell because we need to set the total, and RC is immutable
     let total = Rc::new(Cell::new(0));
 
-    try!(connect("ws://127.0.0.1:9001/getCaseCount", |out| {
-
+    connect("ws://127.0.0.1:9001/getCaseCount", |out| {
         let my_total = total.clone();
 
         move |msg: Message| {
-
-            let count = try!(msg.as_text());
+            let count = msg.as_text()?;
 
             my_total.set(count.parse::<u32>().unwrap());
 
             out.close(CloseCode::Normal)
         }
-
-    }));
+    })?;
 
     Ok(total.get())
 }
 
 fn update_reports() -> Result<()> {
     let report_url = format!("ws://127.0.0.1:9001/updateReports?agent={}", AGENT);
 
-    connect(report_url, |out| {
-        move |_| {
-            out.close(CloseCode::Normal)
-        }
-    })
+    connect(report_url, |out| move |_| out.close(CloseCode::Normal))
 }

examples/autobahn-server.rs

@@ -1,30 +1,25 @@
+extern crate env_logger;
 /// WebSocket server used for testing against the Autobahn Test Suite. This is basically the server
 /// example without printing output or comments.
-
 extern crate ws;
-extern crate env_logger;
 
-#[cfg(feature="permessage-deflate")]
+#[cfg(feature = "permessage-deflate")]
 use ws::deflate::DeflateHandler;
 
-#[cfg(not(feature="permessage-deflate"))]
-fn main () {
+#[cfg(not(feature = "permessage-deflate"))]
+fn main() {
     env_logger::init();
 
     ws::listen("127.0.0.1:3012", |out| {
-        move |msg| {
-            out.send(msg)
-        }
+        move |msg| out.send(msg)
     }).unwrap()
 }
 
-#[cfg(feature="permessage-deflate")]
-fn main () {
+#[cfg(feature = "permessage-deflate")]
+fn main() {
     env_logger::init();
 
     ws::listen("127.0.0.1:3012", |out| {
-        DeflateHandler::new(move |msg| {
-            out.send(msg)
-        })
+        DeflateHandler::new(move |msg| out.send(msg))
     }).unwrap();
 }

examples/bench-server.rs

@@ -1,16 +1,16 @@
-
 /// WebSocket server used for testing the bench example.
 extern crate ws;
 
-use ws::{Builder, Settings, Sender};
+use ws::{Builder, Sender, Settings};
 
-fn main () {
-    Builder::new().with_settings(Settings {
-        max_connections: 10_000,
-        ..Settings::default()
-    }).build(|out: Sender| {
-        move |msg| {
-            out.send(msg)
-        }
-    }).unwrap().listen("127.0.0.1:3012").unwrap();
+fn main() {
+    Builder::new()
+        .with_settings(Settings {
+            max_connections: 10_000,
+            ..Settings::default()
+        })
+        .build(|out: Sender| move |msg| out.send(msg))
+        .unwrap()
+        .listen("127.0.0.1:3012")
+        .unwrap();
 }

examples/bench.rs

@@ -1,25 +1,24 @@
+extern crate env_logger;
+extern crate time;
+extern crate url;
 /// A simple, but immature, benchmark client for destroying other WebSocket frameworks and proving
 /// WS-RS's performance excellence. ;)
 /// Make sure you allow for enough connections in your OS (e.g. ulimit -Sn 10000).
-
 extern crate ws;
-extern crate url;
-extern crate time;
-extern crate env_logger;
 
 // Try this against node for some fun
 
 // TODO: Separate this example into a separate lib
 // TODO: num threads, num connections per thread, num concurrent connections per thread, num
 // messages per connection, length of message, text or binary
 
-use ws::{Builder, Settings, Sender, CloseCode, Handler, Message, Handshake, Result};
+use ws::{Builder, CloseCode, Handler, Handshake, Message, Result, Sender, Settings};
 
 const CONNECTIONS: usize = 10_000; // simultaneous
 const MESSAGES: u32 = 10;
 static MESSAGE: &'static str = "TEST TEST TEST TEST TEST TEST TEST TEST";
 
-fn main () {
+fn main() {
     env_logger::init();
 
     let url = url::Url::parse("ws://127.0.0.1:3012").unwrap();
@@ -32,19 +31,18 @@ fn main () {
     }
 
     impl Handler for Connection {
-
         fn on_open(&mut self, _: Handshake) -> Result<()> {
-            try!(self.out.send(MESSAGE));
+            self.out.send(MESSAGE)?;
             self.count += 1;
             Ok(self.time = time::precise_time_ns())
         }
 
         fn on_message(&mut self, msg: Message) -> Result<()> {
             assert_eq!(msg.as_text().unwrap(), MESSAGE);
             if self.count > MESSAGES {
-                try!(self.out.close(CloseCode::Normal));
+                self.out.close(CloseCode::Normal)?;
             } else {
-                try!(self.out.send(MESSAGE));
+                self.out.send(MESSAGE)?;
                 let time = time::precise_time_ns();
                 // println!("time {}", time -self.time);
                 self.total += time - self.time;
@@ -55,23 +53,26 @@ fn main () {
         }
     }
 
-    let mut ws = Builder::new().with_settings(Settings {
-        max_connections: CONNECTIONS,
-        ..Settings::default()
-    }).build(|out| {
-        Connection {
+    let mut ws = Builder::new()
+        .with_settings(Settings {
+            max_connections: CONNECTIONS,
+            ..Settings::default()
+        })
+        .build(|out| Connection {
             out: out,
             count: 0,
             time: 0,
             total: 0,
-        }
-    }).unwrap();
-
+        })
+        .unwrap();
 
     for _ in 0..CONNECTIONS {
         ws.connect(url.clone()).unwrap();
     }
     let start = time::precise_time_ns();
     ws.run().unwrap();
-    println!("Total time. {}", (time::precise_time_ns() - start) / 1_000_000)
+    println!(
+        "Total time. {}",
+        (time::precise_time_ns() - start) / 1_000_000
+    )
 }