feat: ✨ every parameter comes from start arguments instead of config file

configs/config.txt

@@ -1,2 +0,0 @@
-server_address:127.0.0.1
-port:2444

src/client.rs

@@ -28,9 +28,8 @@ pub async fn start(config: Config, debug: bool) {
     }
 }
 
-pub async fn connect(config: &Config, debug: bool) -> Option<(WebSocketSender, WebSocketReceiver)> {
+async fn connect(config: &Config, debug: bool) -> Option<(WebSocketSender, WebSocketReceiver)> {
-    let ws_connection =
+    let ws_connection = match connect_async(format!("ws://{}:{}", config.ip, config.port)).await {
-        match connect_async(format!("ws://{}:{}", config.server_address, config.port)).await {
         Ok(ws_connection) => ws_connection,
         Err(err_val) => {
             if debug {
@@ -44,10 +43,7 @@ pub async fn connect(config: &Config, debug: bool) -> Option<(WebSocketSender, W
     Some((ws_sender, ws_receiver))
 }
 
-pub async fn serve(
+async fn serve((ws_sender, mut ws_receiver): (WebSocketSender, WebSocketReceiver), debug: bool) {
-    (ws_sender, mut ws_receiver): (WebSocketSender, WebSocketReceiver),
-    debug: bool,
-) {
     let ws_sender = Arc::new(Mutex::new(ws_sender));
     while let Some(message) = receive(&mut ws_receiver, debug).await {
         match serde_json::from_str::<Payload>(&message[..]) {
@@ -68,7 +64,7 @@ pub async fn serve(
     }
 }
 
-pub async fn execute(payload: Payload, debug: bool) -> Option<Output> {
+async fn execute(payload: Payload, debug: bool) -> Option<Output> {
     if debug {
         println!("{:#?}", payload);
     }
@@ -87,7 +83,7 @@ pub async fn execute(payload: Payload, debug: bool) -> Option<Output> {
     }
 }
 
-pub async fn receive(ws_receiver: &mut WebSocketReceiver, debug: bool) -> Option<String> {
+async fn receive(ws_receiver: &mut WebSocketReceiver, debug: bool) -> Option<String> {
     match ws_receiver.next().await {
         Some(message) => match message {
             Ok(message) => {
@@ -116,7 +112,7 @@ pub async fn receive(ws_receiver: &mut WebSocketReceiver, debug: bool) -> Option
     }
 }
 
-pub async fn send(
+async fn send(
     output: Option<Output>,
     payload: Payload,
     ws_sender: Arc<Mutex<WebSocketSender>>,

src/lib.rs

@@ -6,18 +6,19 @@ pub mod client;
 pub mod server;
 pub mod utils;
 
+#[derive(Debug)]
 pub enum Runner {
     Server,
     Client,
 }
-
+#[derive(Debug)]
 pub enum RunnerMode {
     State(Runner, bool),
 }
 
 #[derive(Debug, Clone)]
 pub struct Config {
-    pub server_address: IpAddr,
+    pub ip: IpAddr,
     pub port: u16,
 }
 

src/main.rs

@@ -1,22 +1,14 @@
-use rust_remote::{
+use rust_remote::{utils::take_args, Runner, RunnerMode};
-    utils::{read_config, take_args},
-    Runner, RunnerMode,
-};
 
 #[tokio::main]
 async fn main() {
     println!("Hello, world!");
 
-    let config = match read_config() {
+    let args = take_args();
-        Some(config) => config,
+    println!("{:#?}", args);
-        None => {
-            eprintln!("Error: Read Config");
-            return;
-        }
-    };
 
-    match take_args() {
+    match args {
-        Some(runner_mode) => match runner_mode {
+        Some((runner_mode, config)) => match runner_mode {
             RunnerMode::State(Runner::Server, false) => {
                 rust_remote::server::start(config, false).await
             }

src/server.rs

@@ -46,8 +46,8 @@ pub async fn start(config: Config, debug: bool) {
         }
     }
 }
-pub async fn setup(config: Config, debug: bool) -> Option<TcpListener> {
+async fn setup(config: Config, debug: bool) -> Option<TcpListener> {
-    match TcpListener::bind(format!("{}:{}", config.server_address, config.port)).await {
+    match TcpListener::bind(format!("{}:{}", config.ip, config.port)).await {
         Ok(listener) => Some(listener),
         Err(err_val) => {
             if debug {
@@ -58,7 +58,7 @@ pub async fn setup(config: Config, debug: bool) -> Option<TcpListener> {
     }
 }
 
-pub async fn establish_connection(
+async fn establish_connection(
     listener: &TcpListener,
     debug: bool,
 ) -> Option<(WebSocketSender, WebSocketReceiver)> {
@@ -81,7 +81,7 @@ pub async fn establish_connection(
     }
 }
 
-pub async fn payload_from_input(debug: bool) -> Option<Payload> {
+async fn payload_from_input(debug: bool) -> Option<Payload> {
     println!("User");
     // let user = match get_input() {
     //     Some(input) => input,
@@ -116,7 +116,7 @@ pub async fn payload_from_input(debug: bool) -> Option<Payload> {
     }
 }
 
-pub fn get_input(debug: bool) -> Option<String> {
+fn get_input(debug: bool) -> Option<String> {
     let mut payload_input: String = String::new();
     match stdin().read_line(&mut payload_input) {
         Ok(_) => Some(payload_input.trim().to_string()),
@@ -129,7 +129,7 @@ pub fn get_input(debug: bool) -> Option<String> {
     }
 }
 
-pub async fn receive(ws_receiver: Arc<Mutex<WebSocketReceiver>>, debug: bool) -> Option<String> {
+async fn receive(ws_receiver: Arc<Mutex<WebSocketReceiver>>, debug: bool) -> Option<String> {
     match ws_receiver.lock().await.next().await {
         Some(message) => match message {
             Ok(message) => {
@@ -158,7 +158,7 @@ pub async fn receive(ws_receiver: Arc<Mutex<WebSocketReceiver>>, debug: bool) ->
     }
 }
 
-pub async fn send(payload: Payload, ws_sender: Arc<Mutex<WebSocketSender>>, debug: bool) -> bool {
+async fn send(payload: Payload, ws_sender: Arc<Mutex<WebSocketSender>>, debug: bool) -> bool {
     let payload = serde_json::json!(payload);
     let result = ws_sender
         .lock()

src/utils.rs

@@ -1,57 +1,58 @@
-use std::{env, fs::File, io::Read};
+use std::{env, net::IpAddr};
 
 use crate::{Config, Runner, RunnerMode};
 
-pub fn take_args() -> Option<RunnerMode> {
+pub fn take_args() -> Option<(RunnerMode, Config)> {
     let args: Vec<String> = env::args().collect();
-    if args.len() > 1 {
+    let mut runner = Runner::Server;
-        let runner = match &args[1][..] {
+    let mut debug = false;
-            "--server" => Runner::Server,
+    let mut ip = "127.0.0.1".to_string();
-            "--client" => Runner::Client,
+    let mut port = "3444".to_string();
-            _ => return None,
+    for (i, arg) in args.iter().enumerate() {
-        };
+        match arg.as_str() {
-        let debug = if args.len() > 2 {
+            "--server" | "-sv" => runner = Runner::Server,
-            match &args[2][..] {
+            "--client" | "-cl" => runner = Runner::Client,
-                "--debug" => true,
+            "--debug" | "-d" => debug = true,
-                _ => return None,
+            "--ip" | "i" => ip = args[i + 1].clone(),
+            "--port" | "p" => port = args[i + 1].clone(),
+            "--help" | "-h" => {
+                show_help();
+                std::process::exit(0);
             }
-        } else {
+            _ => continue,
-            false
-        };
-        Some(RunnerMode::State(runner, debug))
-    } else {
-        None
         }
+    }
+    let ip = match ip.parse::<IpAddr>() {
+        Ok(ip) => ip,
+        Err(err_val) => {
+            eprintln!("Error: IP Parse | {}", err_val);
+            return None;
+        }
+    };
+
+    let port = match port.parse::<u16>() {
+        Ok(port) => port,
+        Err(err_val) => {
+            eprintln!("Error: Port Parse | {}", err_val);
+            return None;
+        }
+    };
+
+    let config = Config { ip, port };
+
+    let runner_mode = RunnerMode::State(runner, debug);
+    Some((runner_mode, config))
 }
 
-pub fn read_config() -> Option<Config> {
+fn show_help() {
-    let mut config_file = match File::open("configs/config.txt") {
+    println!("\n\n\n");
-        Ok(config_file) => config_file,
+    println!("   Arguments          |  Details                    |  Defaults");
-        Err(_) => return None,
+    println!("----------------------------------------------------------------------");
-    };
+    println!("   -i  -> --ip        |  Specifies IP Address       |  127.0.0.1");
-    let mut configs = String::new();
+    println!("   -p  -> --port      |  Specifies Port Address     |  3444");
-    match config_file.read_to_string(&mut configs) {
+    println!("   -sv -> --server    |  Starts as a Server         |  True");
-        Ok(_) => {
+    println!("   -cl -> --client    |  Starts as a Client         |  False");
-            let configs: Vec<String> = configs.split('\n').map(|x| x.to_string()).collect();
+    println!("   -d  -> --debug     |  Starts in Debug Mode       |  False");
-            let server_address = match configs[0].split(':').last() {
+    println!("   -h  -> --help      |  Shows Help                 |  False");
-                Some(server_address_unchecked) => match server_address_unchecked.parse() {
+    println!("\n\n\n");
-                    Ok(server_address) => server_address,
-                    Err(_) => return None,
-                },
-                None => return None,
-            };
-            let port = match configs[1].split(':').last() {
-                Some(port_unchecked) => match port_unchecked.parse() {
-                    Ok(port) => port,
-                    Err(_) => return None,
-                },
-                None => return None,
-            };
-            Some(Config {
-                server_address,
-                port,
-            })
-        }
-        Err(_) => None,
-    }
 }