mumctl: refactor matching of config values

1 files changed, 170 insertions, 143 deletions

diff --git a/mumctl/src/main.rs b/mumctl/src/main.rs
index 7c36f02..0392b2c 100644
--- a/mumctl/src/main.rs
+++ b/mumctl/src/main.rs
@@ -96,130 +96,17 @@ fn main() {
 
     if let Some(matches) = matches.subcommand_matches("server") {
         if let Some(matches) = matches.subcommand_matches("connect") {
-            let host = matches.value_of("host").unwrap();
-            let username = matches.value_of("username").unwrap();
-            let port = match matches.value_of("port").map(|e| e.parse()) {
-                None => Some(64738),
-                Some(Err(_)) => None,
-                Some(Ok(v)) => Some(v),
-            };
-            if let Some(port) = port {
-                err_print!(send_command(Command::ServerConnect {
-                    host: host.to_string(),
-                    port,
-                    username: username.to_string(),
-                    accept_invalid_cert: true, //TODO
-                }));
-            }
+            match_server_connect(matches);
         } else if let Some(_) = matches.subcommand_matches("disconnect") {
             err_print!(send_command(Command::ServerDisconnect));
         } else if let Some(matches) = matches.subcommand_matches("config") {
-            let server_name = matches.value_of("server_name").unwrap();
-            if let Some(servers) = &mut config.servers {
-                let server = servers
-                    .iter_mut()
-                    .find(|s| s.name == server_name);
-                if let Some(server) = server {
-                    if let Some(var_name) = matches.value_of("var_name") {
-                        if let Some(var_value) = matches.value_of("var_value") {
-                            // save var_value in var_name
-                            match var_name {
-                                "name" => {
-                                    println!("{} use mumctl server rename instead!", "error:".red());
-                                },
-                                "host" => {
-                                    server.host = var_value.to_string();
-                                },
-                                "port" => {
-                                    server.port = Some(var_value.parse().unwrap());
-                                },
-                                "username" => {
-                                    server.username = Some(var_value.to_string());
-                                },
-                                "password" => {
-                                    server.password = Some(var_value.to_string()); //TODO ask stdin if empty
-                                },
-                                _ => {
-                                    println!("{} variable {} not found", "error:".red(), var_name);
-                                },
-                            };
-                        } else { // var_value is None
-                            // print value of var_name
-                            println!("{}", match var_name {
-                                "name" => { server.name.to_string() },
-                                "host" => { server.host.to_string() },
-                                "port" => { server.port.map(|s| s.to_string()).unwrap_or(format!("{} not set", "error:".red())) },
-                                "username" => { server.username.as_ref().map(|s| s.to_string()).unwrap_or(format!("{} not set", "error:".red())) },
-                                "password" => { server.password.as_ref().map(|s| s.to_string()).unwrap_or(format!("{} not set", "error:".red())) },
-                                _ => { format!("{} unknown variable", "error:".red()) },
-                            });
-                        }
-                    } else { // var_name is None
-                        // print server config
-                        print!("{}{}{}{}",
-                                 format!("host: {}\n", server.host.to_string()),
-                                 server.port.map(|s| format!("port: {}\n", s)).unwrap_or("".to_string()),
-                                 server.username.as_ref().map(|s| format!("username: {}\n", s)).unwrap_or("".to_string()),
-                                 server.password.as_ref().map(|s| format!("password: {}\n", s)).unwrap_or("".to_string()),
-                        )
-                    }
-                } else { // server is None
-                    println!("{} server {} not found", "error:".red(), server_name);
-                }
-            } else { // servers is None
-                println!("{} no servers found in configuration", "error:".red());
-            }
+            match_server_config(matches, &mut config);
         } else if let Some(matches) = matches.subcommand_matches("rename") {
-            if let Some(servers) = &mut config.servers {
-                let prev_name = matches.value_of("prev_name").unwrap();
-                let next_name = matches.value_of("next_name").unwrap();
-                if let Some(server) = servers
-                                      .iter_mut()
-                                      .find(|s| s.name == prev_name) {
-                    server.name = next_name.to_string();
-                } else {
-                    println!("{} server {} not found", "error:".red(), prev_name);
-                }
-            }
+            match_server_rename(matches, &mut config);
         } else if let Some(matches) = matches.subcommand_matches("remove") {
-            let name = matches.value_of("name").unwrap();
-            if config.servers.is_none() {
-                println!("{} no servers found in configuration", "error:".red());
-            } else {
-                let prev_amount = config.servers.as_ref().unwrap().len();
-                config.servers = config.servers.map(|servers| servers.into_iter().filter(|server| server.name != name).collect());
-                if prev_amount == config.servers.as_ref().unwrap().len() {
-                    println!("{} server {} not found", "error:".red(), name);
-                }
-            }
+            match_server_remove(matches, &mut config);
         } else if let Some(matches) = matches.subcommand_matches("add") {
-            let name = matches.value_of("name").unwrap().to_string();
-            let host = matches.value_of("host").unwrap().to_string();
-            // optional arguments map None to None
-            let port = matches.value_of("port").map(|s| s.parse().unwrap());
-            let username = matches.value_of("username").map(|s| s.to_string());
-            let password = matches.value_of("password").map(|s| s.to_string());
-            if let Some(servers) = &mut config.servers {
-                if servers.iter().any(|s| s.name == name) {
-                    println!("{} a server named {} already exists", "error:".red(), name);
-                } else {
-                    servers.push(ServerConfig {
-                        name,
-                        host,
-                        port,
-                        username,
-                        password,
-                    });
-                }
-            } else {
-                config.servers = Some(vec![ServerConfig {
-                    name,
-                    host,
-                    port,
-                    username,
-                    password,
-                }]);
-            }
+            match_server_add(matches, &mut config);
         }
     } else if let Some(matches) = matches.subcommand_matches("channel") {
         if let Some(_matches) = matches.subcommand_matches("list") {
@@ -237,34 +124,12 @@ fn main() {
                 channel_identifier: matches.value_of("channel").unwrap().to_string()
             }));
         }
-    } else if let Some(_matches) = matches.subcommand_matches("status") {
+    } else if let Some(_) = matches.subcommand_matches("status") {
         match send_command(Command::Status) {
             Ok(res) => match res {
                 Some(CommandResponse::Status { server_state }) => {
-                    println!(
-                        "Connected to {} as {}",
-                        server_state.host, server_state.username
-                    );
-                    let own_channel = server_state
-                        .channels
-                        .iter()
-                        .find(|e| e.users.iter().any(|e| e.name == server_state.username))
-                        .unwrap();
-                    println!(
-                        "Currently in {} with {} other client{}:",
-                        own_channel.name,
-                        own_channel.users.len() - 1,
-                        if own_channel.users.len() == 2 {
-                            ""
-                        } else {
-                            "s"
-                        }
-                    );
-                    println!("{}{}", INDENTATION, own_channel.name);
-                    for user in &own_channel.users {
-                        println!("{}{}{}", INDENTATION, INDENTATION, user);
-                    }
-                }
+                    parse_status(&server_state);
+                },
                 _ => unreachable!(),
             },
             Err(e) => println!("{} {}", "error:".red(), e),
@@ -300,6 +165,168 @@ fn main() {
     config.write_default_cfg();
 }
 
+fn match_server_connect(matches : &clap::ArgMatches<>) {
+    let host = matches.value_of("host").unwrap();
+    let username = matches.value_of("username").unwrap();
+    let port = match matches.value_of("port").map(|e| e.parse()) {
+        None => Some(64738),
+        Some(Err(_)) => None,
+        Some(Ok(v)) => Some(v),
+    };
+    if let Some(port) = port {
+        err_print!(send_command(Command::ServerConnect {
+            host: host.to_string(),
+            port,
+            username: username.to_string(),
+            accept_invalid_cert: true, //TODO
+        }));
+    }
+}
+
+fn match_server_config(matches: &clap::ArgMatches<>, config: &mut mumlib::config::Config) {
+    let server_name = matches.value_of("server_name").unwrap();
+    if let Some(servers) = &mut config.servers {
+        let server = servers
+            .iter_mut()
+            .find(|s| s.name == server_name);
+        if let Some(server) = server {
+            if let Some(var_name) = matches.value_of("var_name") {
+                if let Some(var_value) = matches.value_of("var_value") {
+                    // save var_value in var_name (if it is valid)
+                    match var_name {
+                        "name" => {
+                            println!("{} use mumctl server rename instead!", "error:".red());
+                        },
+                        "host" => {
+                            server.host = var_value.to_string();
+                        },
+                        "port" => {
+                            server.port = Some(var_value.parse().unwrap());
+                        },
+                        "username" => {
+                            server.username = Some(var_value.to_string());
+                        },
+                        "password" => {
+                            server.password = Some(var_value.to_string()); //TODO ask stdin if empty
+                        },
+                        _ => {
+                            println!("{} variable {} not found", "error:".red(), var_name);
+                        },
+                    };
+                } else { // var_value is None
+                    // print value of var_name
+                    println!("{}", match var_name {
+                        "name" => { server.name.to_string() },
+                        "host" => { server.host.to_string() },
+                        "port" => { server.port.map(|s| s.to_string()).unwrap_or(format!("{} not set", "error:".red())) },
+                        "username" => { server.username.as_ref().map(|s| s.to_string()).unwrap_or(format!("{} not set", "error:".red())) },
+                        "password" => { server.password.as_ref().map(|s| s.to_string()).unwrap_or(format!("{} not set", "error:".red())) },
+                        _ => { format!("{} unknown variable", "error:".red()) },
+                    });
+                }
+            } else { // var_name is None
+                // print server config
+                print!("{}{}{}{}",
+                       format!("host: {}\n", server.host.to_string()),
+                       server.port.map(|s| format!("port: {}\n", s)).unwrap_or("".to_string()),
+                       server.username.as_ref().map(|s| format!("username: {}\n", s)).unwrap_or("".to_string()),
+                       server.password.as_ref().map(|s| format!("password: {}\n", s)).unwrap_or("".to_string()),
+                )
+            }
+        } else { // server is None
+            println!("{} server {} not found", "error:".red(), server_name);
+        }
+    } else { // servers is None
+        println!("{} no servers found in configuration", "error:".red());
+    }
+}
+
+fn match_server_rename(matches: &clap::ArgMatches<>, config: &mut mumlib::config::Config) {
+    if let Some(servers) = &mut config.servers {
+        let prev_name = matches.value_of("prev_name").unwrap();
+        let next_name = matches.value_of("next_name").unwrap();
+        if let Some(server) = servers
+                                .iter_mut()
+                                .find(|s| s.name == prev_name) {
+            server.name = next_name.to_string();
+        } else {
+            println!("{} server {} not found", "error:".red(), prev_name);
+        }
+    }
+}
+
+fn match_server_remove(matches: &clap::ArgMatches<>, config: &mut mumlib::config::Config) {
+    let name = matches.value_of("name").unwrap();
+    if let Some(servers) = &mut config.servers {
+        match servers.iter().position(|server| server.name == name) {
+            Some(idx) => {
+                servers.remove(idx);
+            },
+            None => {
+                println!("{} server {} not found", "error:".red(), name);
+            }
+        };
+    } else {
+        println!("{} no servers found in configuration", "error:".red());
+    }
+}
+
+fn match_server_add(matches: &clap::ArgMatches<>, config: &mut mumlib::config::Config) {
+    let name = matches.value_of("name").unwrap().to_string();
+    let host = matches.value_of("host").unwrap().to_string();
+    // optional arguments map None to None
+    let port = matches.value_of("port").map(|s| s.parse().unwrap());
+    let username = matches.value_of("username").map(|s| s.to_string());
+    let password = matches.value_of("password").map(|s| s.to_string());
+    if let Some(servers) = &mut config.servers {
+        if servers.iter().any(|s| s.name == name) {
+            println!("{} a server named {} already exists", "error:".red(), name);
+        } else {
+            servers.push(ServerConfig {
+                name,
+                host,
+                port,
+                username,
+                password,
+            });
+        }
+    } else {
+        config.servers = Some(vec![ServerConfig {
+            name,
+            host,
+            port,
+            username,
+            password,
+        }]);
+    }
+}
+
+fn parse_status(server_state: &mumlib::state::Server) {
+    println!(
+        "Connected to {} as {}",
+        server_state.host, server_state.username
+    );
+    let own_channel = server_state
+        .channels
+        .iter()
+        .find(|e| e.users.iter().any(|e| e.name == server_state.username))
+        .unwrap();
+    println!(
+        "Currently in {} with {} other client{}:",
+        own_channel.name,
+        own_channel.users.len() - 1,
+        if own_channel.users.len() == 2 {
+            ""
+        } else {
+            "s"
+        }
+    );
+    println!("{}{}", INDENTATION, own_channel.name);
+    for user in &own_channel.users {
+        println!("{}{}{}", INDENTATION, INDENTATION, user);
+    }
+}
+
 fn send_command(command: Command) -> mumlib::error::Result<Option<CommandResponse>> {
     let (tx_client, rx_client) =
         ipc::channel::<mumlib::error::Result<Option<CommandResponse>>>().unwrap();