cargo fmt

Author: euank

src/main.rs

@@ -10,8 +10,8 @@ extern crate clap;
 #[macro_use]
 extern crate log;
 extern crate env_logger;
-use log::LogLevelFilter;
 use env_logger::LogBuilder;
+use log::LogLevelFilter;
 
 use std::convert::From;
 
@@ -25,10 +25,9 @@ extern crate isatty;
 use isatty::stdout_isatty;
 
 use std::io::prelude::*;
+use std::io::stdout;
 use std::io::BufReader;
 use std::io::Error as IoError;
-use std::io::stdout;
-
 
 /// Actions that threads can take
 #[derive(Debug)]
@@ -60,33 +59,31 @@ impl From<&'static str> for Action {
     }
 }
 
-
 fn main() {
     // Catch signals we expect to exit cleanly from
     // I don't think rust actually sends SIGPIPE, but we'll catch it anyway
     let signal = chan_signal::notify(&[Signal::INT, Signal::TERM, Signal::PIPE]);
 
-
     // Parse args
     let matches = clap_app!
-        (hashpipe =>
-         (version: crate_version!())
-         (author: crate_authors!())
-         (about: "#|: Pipes data to and from an IRC connection")
-         (@arg server: -s --server +required +takes_value "IRC server to connect to")
-         (@arg port: -p --port +takes_value "Port to use (default: 6667, or 6697 with SSL)")
-         (@arg no_ssl: -d long("--no-ssl") "Disable SSL encryption")
-         (@arg nick: -n --nick +takes_value "Nickname to use (default: hashpipe)")
-         (@arg channels: -c --channels +takes_value "Channel(s) to speak in \
-          (defalt: #hashpipe, or nothing if using raw input)")
-         // NOTE: long() is a required workaround for parsing long options with
-         // hyphens; see https://github.com/kbknapp/clap-rs/issues/321
-         (@arg raw_out: -o long("--raw-out") "Echo everything from the IRC server directly")
-         (@arg raw_in: -i long("--raw-in") "Interpret STDIN as raw IRC commands")
-         (@arg v: -v +multiple "Verbosity (1 for info, 2 for debug)")
-         (@arg quiet: -q "Only print errors (overrides -v; overridden by raw output)")
-        )
-        .get_matches();
+    (hashpipe =>
+     (version: crate_version!())
+     (author: crate_authors!())
+     (about: "#|: Pipes data to and from an IRC connection")
+     (@arg server: -s --server +required +takes_value "IRC server to connect to")
+     (@arg port: -p --port +takes_value "Port to use (default: 6667, or 6697 with SSL)")
+     (@arg no_ssl: -d long("--no-ssl") "Disable SSL encryption")
+     (@arg nick: -n --nick +takes_value "Nickname to use (default: hashpipe)")
+     (@arg channels: -c --channels +takes_value "Channel(s) to speak in \
+      (defalt: #hashpipe, or nothing if using raw input)")
+     // NOTE: long() is a required workaround for parsing long options with
+     // hyphens; see https://github.com/kbknapp/clap-rs/issues/321
+     (@arg raw_out: -o long("--raw-out") "Echo everything from the IRC server directly")
+     (@arg raw_in: -i long("--raw-in") "Interpret STDIN as raw IRC commands")
+     (@arg v: -v +multiple "Verbosity (1 for info, 2 for debug)")
+     (@arg quiet: -q "Only print errors (overrides -v; overridden by raw output)")
+    )
+    .get_matches();
 
     let raw_out = matches.is_present("raw_out");
     let raw_in = matches.is_present("raw_in");
@@ -98,9 +95,11 @@ fn main() {
     let port = matches.value_of("port").and_then(|p| p.parse().ok());
 
     // Filter empty strings from channel names
-    let sanitized_chans: Vec<String> = matches.value_of("channels")
+    let sanitized_chans: Vec<String> = matches
+        .value_of("channels")
         .map(|chans| {
-            chans.split(',')
+            chans
+                .split(',')
                 .filter(|x| *x != "")
                 .map(|x| x.to_string())
                 .collect()
@@ -113,7 +112,6 @@ fn main() {
         vec!["#hashpipe".to_string()]
     };
 
-
     // Set up logger
     let mut builder = LogBuilder::new();
     let level = match (matches.occurrences_of("v"), quiet) {
@@ -125,7 +123,6 @@ fn main() {
     builder.filter(None, level);
     builder.init().unwrap();
 
-
     // Set up IRC server
     let cfg = Config {
         nickname: Some(nick),
@@ -235,39 +232,51 @@ fn main() {
 
 /// Manage IRC connection; read and print messages; signal on JOIN or QUIT
 fn run_irc(client: IrcClient, raw: bool, quiet: bool, sjoin: chan::Sender<Action>) {
-    client.identify().unwrap_or_else(|err| sjoin.send(From::from(err)));
+    client
+        .identify()
+        .unwrap_or_else(|err| sjoin.send(From::from(err)));
 
     let res = client.for_each_incoming(|msg| {
         if raw {
             print!("{}", msg);
-            stdout().flush().unwrap_or_else(|err| sjoin.send(From::from(err)));
+            stdout()
+                .flush()
+                .unwrap_or_else(|err| sjoin.send(From::from(err)));
         }
         match msg.command {
             Command::JOIN(ref _channel, ref _a, ref _b) => sjoin.send(Action::Join),
             Command::PRIVMSG(ref target, ref what_was_said) => {
                 if !raw && !quiet {
-                    println!("{}->{}: {}",
-                                msg.source_nickname().unwrap_or("* "),
-                                target,
-                                what_was_said);
-                    stdout().flush().unwrap_or_else(|err| sjoin.send(From::from(err)));
+                    println!(
+                        "{}->{}: {}",
+                        msg.source_nickname().unwrap_or("* "),
+                        target,
+                        what_was_said
+                    );
+                    stdout()
+                        .flush()
+                        .unwrap_or_else(|err| sjoin.send(From::from(err)));
                 }
             }
             Command::NOTICE(ref target, ref what_was_said) => {
                 if !raw && !quiet {
-                    println!("{}->{}: {}",
-                                msg.source_nickname().unwrap_or("* "),
-                                target,
-                                what_was_said);
-                    stdout().flush().unwrap_or_else(|err| sjoin.send(From::from(err)));
+                    println!(
+                        "{}->{}: {}",
+                        msg.source_nickname().unwrap_or("* "),
+                        target,
+                        what_was_said
+                    );
+                    stdout()
+                        .flush()
+                        .unwrap_or_else(|err| sjoin.send(From::from(err)));
                 }
             }
             Command::QUIT(ref _quitmessage) => sjoin.send(Action::Quit),
             Command::Response(ref response, ref command, ref err) => {
                 // Handle un-joinable channels
                 let the_problem = command.get(1).map_or("", |s| &*s);
-                let errmsg = the_problem.to_string() + ": " +
-                                &err.clone().unwrap_or("".to_string());
+                let errmsg =
+                    the_problem.to_string() + ": " + &err.clone().unwrap_or("".to_string());
 
                 match *response {
                     Response::ERR_CHANNELISFULL => sjoin.send(Action::JoinFail(errmsg)),
@@ -300,14 +309,15 @@ fn run_io(client: IrcClient, channels: Vec<String>, raw: bool, sdone: chan::Send
                 if raw {
                     let raw_line = ln + "\r\n"; // IRC line terminator
                     match Message::from_str(&raw_line) {
-                        Ok(msg) => {
-                            client.send(msg).unwrap_or_else(|err| sdone.send(From::from(err)))
-                        }
+                        Ok(msg) => client
+                            .send(msg)
+                            .unwrap_or_else(|err| sdone.send(From::from(err))),
                         Err(err) => sdone.send(From::from(err)),
                     }
                 } else {
                     for channel in &channels {
-                        client.send_privmsg(&channel, &ln)
+                        client
+                            .send_privmsg(&channel, &ln)
                             .unwrap_or_else(|err| sdone.send(From::from(err)));
                     }
                 }