Closes #3. Use thiserror. Fix clippy stuff

7 files changed, 121 insertions, 121 deletions

diff --git a/Cargo.lock b/Cargo.lock
index ad227e6..c0f07f7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1021,18 +1021,18 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.69"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
@@ -1315,9 +1315,9 @@ checksum = "5ee073c9e4cd00e28217186dbe12796d692868f432bf2e97ee73bed0c56dfa01"
 
 [[package]]
 name = "syn"
-version = "2.0.39"
+version = "2.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
+checksum = "74f1bdc9872430ce9b75da68329d1c1746faf50ffac5f19e02b71e37ff881ffb"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1360,18 +1360,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.50"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
+checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.50"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
+checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1734,6 +1734,7 @@ dependencies = [
  "reqwest",
  "serde",
  "serde_json",
+ "thiserror",
  "tokio",
  "tokio-tungstenite",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 461b0bf..a60d788 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,5 +19,6 @@ indicatif = "0.17"
 reqwest = { version = "0.11", features = ["blocking"] }
 serde = "1.0"
 serde_json = "1.0"
+thiserror = "1.0.57"
 tokio = { version = "1.36", features = ["macros", "rt-multi-thread", "io-std"] }
 tokio-tungstenite = "0.21"
diff --git a/src/config.rs b/src/config.rs
index 78795a3..d28e111 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -9,8 +9,8 @@ pub struct Config {
 impl Config {
     pub fn load() -> Result<Config, config::ConfigError> {
         let builder = config::Config::builder()
-            .add_source(config::File::with_name("~/.config/webol-cli.toml"))
-            .add_source(config::File::with_name("webol-cli.toml"))
+            .add_source(config::File::with_name("~/.config/webol-cli").required(false))
+            .add_source(config::File::with_name("webol-cli").required(false))
             .add_source(config::Environment::with_prefix("WEBOL_CLI_").separator("_"))
             .build()?;
 
diff --git a/src/error.rs b/src/error.rs
index 531528f..15e4308 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,21 +1,34 @@
 use std::{fmt::Debug, num::ParseIntError};
 
-pub enum CliError {
-    Reqwest(reqwest::Error),
-    Config(config::ConfigError),
-    Serde(serde_json::Error),
-    Parse(ParseIntError),
-    WsResponse,
-}
+use reqwest::header::InvalidHeaderValue;
 
-impl Debug for CliError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Reqwest(err) => err.fmt(f),
-            Self::Config(err) => err.fmt(f),
-            Self::Serde(err) => err.fmt(f),
-            Self::Parse(err) => err.fmt(f),
-            Self::WsResponse => f.write_str("Error in Response"),
-        }
-    }
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("request: {source}")]
+    Reqwest {
+        #[from]
+        source: reqwest::Error,
+    },
+    #[error("config: {source}")]
+    Config {
+        #[from]
+        source: config::ConfigError,
+    },
+    #[error("serde: {source}")]
+    Serde {
+        #[from]
+        source: serde_json::Error,
+    },
+    #[error("parse int: {source}")]
+    Parse {
+        #[from]
+        source: ParseIntError,
+    },
+    #[error("parse header: {source}")]
+    InvalidHeaderValue {
+        #[from]
+        source: InvalidHeaderValue
+    },
+    #[error("ws")]
+    WsResponse,
 }
diff --git a/src/main.rs b/src/main.rs
index 0393183..cdca6cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,7 @@ use std::{fmt::Display, time::Duration};
 use crate::config::Config;
 use clap::{Command, CommandFactory, Parser, Subcommand};
 use clap_complete::{generate, Generator, Shell};
-use error::CliError;
+use error::Error;
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use requests::{device, start::start};
 use reqwest::header::{HeaderMap, HeaderValue};
@@ -66,8 +66,8 @@ enum DeviceCmd {
 }
 
 #[tokio::main]
-async fn main() -> Result<(), CliError> {
-    let config = Config::load().map_err(CliError::Config)?;
+async fn main() -> Result<(), Error> {
+    let config = Config::load()?;
 
     let cli = Args::parse();
 
@@ -99,7 +99,7 @@ async fn main() -> Result<(), CliError> {
         Commands::CliGen { id } => {
             eprintln!("Generating completion file for {id:?}...");
             let mut cmd = Args::command();
-            print_completions(id, &mut cmd)
+            print_completions(id, &mut cmd);
         }
     }
 
@@ -110,26 +110,26 @@ fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
     generate(gen, cmd, cmd.get_name().to_string(), &mut std::io::stdout());
 }
 
-fn default_headers(config: &Config) -> Result<HeaderMap, CliError> {
+fn default_headers(config: &Config) -> Result<HeaderMap, Error> {
     let mut map = HeaderMap::new();
     map.append(
         "Accept-Content",
-        HeaderValue::from_str("application/json").unwrap(),
+        HeaderValue::from_str("application/json")?
     );
     map.append(
         "Content-Type",
-        HeaderValue::from_str("application/json").unwrap(),
+        HeaderValue::from_str("application/json")?
     );
     map.append(
         "Authorization",
-        HeaderValue::from_str(&config.apikey).unwrap(),
+        HeaderValue::from_str(&config.apikey)?
     );
 
     Ok(map)
 }
 
-fn format_url(config: &Config, path: &str, protocol: Protocols) -> Result<String, CliError> {
-    Ok(format!("{}://{}/{}", protocol, config.server, path))
+fn format_url(config: &Config, path: &str, protocol: &Protocols) -> String {
+    format!("{}://{}/{}", protocol, config.server, path)
 }
 
 fn add_pb(mp: &MultiProgress, template: &str, message: String) -> ProgressBar {
@@ -141,7 +141,7 @@ fn add_pb(mp: &MultiProgress, template: &str, message: String) -> ProgressBar {
     pb
 }
 
-fn finish_pb(pb: ProgressBar, message: String, template: &str) {
+fn finish_pb(pb: &ProgressBar, message: String, template: &str) {
     pb.set_style(ProgressStyle::with_template(template).unwrap());
     pb.finish_with_message(message);
 }
diff --git a/src/requests/device.rs b/src/requests/device.rs
index 5003c4a..a612978 100644
--- a/src/requests/device.rs
+++ b/src/requests/device.rs
@@ -1,4 +1,4 @@
-use crate::{config::Config, default_headers, error::CliError, format_url, Protocols};
+use crate::{config::Config, default_headers, error::Error, format_url, Protocols};
 
 pub async fn put(
     config: &Config,
@@ -6,38 +6,35 @@ pub async fn put(
     mac: String,
     broadcast_addr: String,
     ip: String,
-) -> Result<(), CliError> {
-    let url = format_url(config, "device", Protocols::Http)?;
-    println!("{}", url);
+) -> Result<(), Error> {
+    let url = format_url(config, "device", &Protocols::Http);
+    println!("{url}");
     let res = reqwest::Client::new()
         .put(url)
         .headers(default_headers(config)?)
         .body(format!(
-            r#"{{"id": "{}", "mac": "{}", "broadcast_addr": "{}", "ip": "{}"}}"#,
-            id, mac, broadcast_addr, ip
+            r#"{{"id": "{id}", "mac": "{mac}", "broadcast_addr": "{broadcast_addr}", "ip": "{ip}"}}"#,
         ))
         .send()
-        .await
-        .map_err(CliError::Reqwest)?
+        .await?
         .text()
         .await;
 
-    println!("{:?}", res);
+    println!("{res:?}");
     Ok(())
 }
 
-pub async fn get(config: &Config, id: String) -> Result<(), CliError> {
+pub async fn get(config: &Config, id: String) -> Result<(), Error> {
     let res = reqwest::Client::new()
-        .get(format_url(config, "device", Protocols::Http)?)
+        .get(format_url(config, "device", &Protocols::Http))
         .headers(default_headers(config)?)
-        .body(format!(r#"{{"id": "{}"}}"#, id))
+        .body(format!(r#"{{"id": "{id}"}}"#))
         .send()
-        .await
-        .map_err(CliError::Reqwest)?
+        .await?
         .text()
         .await;
 
-    println!("{:?}", res);
+    println!("{res:?}");
     Ok(())
 }
 
@@ -47,20 +44,18 @@ pub async fn post(
     mac: String,
     broadcast_addr: String,
     ip: String,
-) -> Result<(), CliError> {
+) -> Result<(), Error> {
     let res = reqwest::Client::new()
-        .post(format_url(config, "device", Protocols::Http)?)
+        .post(format_url(config, "device", &Protocols::Http))
         .headers(default_headers(config)?)
         .body(format!(
-            r#"{{"id": "{}", "mac": "{}", "broadcast_addr": "{}", "ip": "{}"}}"#,
-            id, mac, broadcast_addr, ip
+            r#"{{"id": "{id}", "mac": "{mac}", "broadcast_addr": "{broadcast_addr}", "ip": "{ip}"}}"#,
         ))
         .send()
-        .await
-        .map_err(CliError::Reqwest)?
+        .await?
         .text()
         .await;
 
-    println!("{:?}", res);
+    println!("{res:?}");
     Ok(())
 }
diff --git a/src/requests/start.rs b/src/requests/start.rs
index bc63303..7abbbe0 100644
--- a/src/requests/start.rs
+++ b/src/requests/start.rs
@@ -5,64 +5,54 @@ use serde::Deserialize;
 use tokio_tungstenite::{connect_async, tungstenite::Message};
 
 use crate::{
-    add_pb, config::Config, default_headers, error::CliError, finish_pb, format_url, ErrorResponse,
+    add_pb, config::Config, default_headers, error::Error, finish_pb, format_url, ErrorResponse,
     Protocols, DEFAULT_STYLE, DONE_STYLE, ERROR_STYLE, OVERVIEW_DONE, OVERVIEW_ERROR,
     OVERVIEW_STYLE,
 };
 
-pub async fn start(config: &Config, id: String, ping: bool) -> Result<(), CliError> {
+pub async fn start(config: &Config, id: String, ping: bool) -> Result<(), Error> {
     let send_start = MultiProgress::new();
-    let overview = add_pb(&send_start, OVERVIEW_STYLE, format!(") start {}", id));
+    let overview = add_pb(&send_start, OVERVIEW_STYLE, format!(") start {id}"));
 
-    // TODO: calculate average start-time on server
-    let url = format_url(config, "start", Protocols::Http)?;
-    let connect = add_pb(&send_start, DEFAULT_STYLE, format!("connect to {}", url));
+    let url = format_url(config, "start", &Protocols::Http);
+    let connect = add_pb(&send_start, DEFAULT_STYLE, format!("connect to {url}"));
     let res = reqwest::Client::new()
         .post(url)
         .headers(default_headers(config)?)
-        .body(format!(r#"{{"id": "{}", "ping": {}}}"#, id, ping))
+        .body(format!(r#"{{"id": "{id}", "ping": {ping}}}"#))
         .send()
-        .await
-        .map_err(CliError::Reqwest)?;
-    finish_pb(connect, "connected, got response".to_string(), DONE_STYLE);
+        .await?;
+    finish_pb(&connect, "connected, got response".to_string(), DONE_STYLE);
 
     let res_pb = add_pb(&send_start, DEFAULT_STYLE, "analyzing response".to_string());
-    match res.status() {
-        StatusCode::OK => {
-            let body = serde_json::from_str::<StartResponse>(
-                &res.text().await.map_err(CliError::Reqwest)?,
-            )
-            .map_err(CliError::Serde)?;
-
-            if body.boot {
-                finish_pb(res_pb, "sent start packet".to_string(), DONE_STYLE);
-            }
 
-            if ping {
-                let status = status_socket(config, body.uuid, &send_start, &overview, id).await?;
-                if status {
-                    finish_pb(
-                        overview,
-                        format!("successfully started {}", body.id),
-                        OVERVIEW_DONE,
-                    );
-                } else {
-                    finish_pb(
-                        overview,
-                        format!("error while starting {}", body.id),
-                        OVERVIEW_ERROR,
-                    );
-                }
-            }
+    if res.status() == StatusCode::OK {
+        let body = serde_json::from_str::<StartResponse>(&res.text().await?)?;
+
+        if body.boot {
+            finish_pb(&res_pb, "sent start packet".to_string(), DONE_STYLE);
         }
-        _ => {
-            let body = serde_json::from_str::<ErrorResponse>(
-                &res.text().await.map_err(CliError::Reqwest)?,
-            )
-            .map_err(CliError::Serde)?;
 
-            res_pb.finish_with_message(format!("✗ got error: {}", body.error));
+        if ping {
+            let status = status_socket(config, body.uuid, &send_start, &overview, id).await?;
+            if status {
+                finish_pb(
+                    &overview,
+                    format!("successfully started {}", body.id),
+                    OVERVIEW_DONE,
+                );
+            } else {
+                finish_pb(
+                    &overview,
+                    format!("error while starting {}", body.id),
+                    OVERVIEW_ERROR,
+                );
+            }
         }
+    } else {
+        let body = serde_json::from_str::<ErrorResponse>(&res.text().await?)?;
+
+        res_pb.finish_with_message(format!("✗ got error: {}", body.error));
     }
 
     Ok(())
@@ -74,60 +64,60 @@ async fn status_socket(
     pb: &MultiProgress,
     overview: &ProgressBar,
     id: String,
-) -> Result<bool, CliError> {
+) -> Result<bool, Error> {
     let ws_pb = add_pb(pb, DEFAULT_STYLE, "connect to websocket".to_string());
     let (mut ws_stream, _response) =
-        connect_async(format_url(config, "status", Protocols::Websocket)?)
+        connect_async(format_url(config, "status", &Protocols::Websocket))
             .await
             .expect("Failed to connect");
-    finish_pb(ws_pb, "connected to websocket".to_string(), DONE_STYLE);
+    finish_pb(&ws_pb, "connected to websocket".to_string(), DONE_STYLE);
 
     ws_stream.send(Message::Text(uuid.clone())).await.unwrap();
 
     // Get ETA
     let eta_msg = ws_stream.next().await.unwrap().unwrap();
-    let eta = get_eta(eta_msg.into_text().unwrap(), uuid.clone())? + overview.elapsed().as_secs();
-    overview.set_message(format!("/{}) start {}", eta, id));
+    let eta = get_eta(&eta_msg.into_text().unwrap(), &uuid)? + overview.elapsed().as_secs();
+    overview.set_message(format!("/{eta}) start {id}"));
 
     let msg_pb = add_pb(pb, DEFAULT_STYLE, "await message".to_string());
     let msg = ws_stream.next().await.unwrap();
-    finish_pb(msg_pb, "received message".to_string(), DONE_STYLE);
+    finish_pb(&msg_pb, "received message".to_string(), DONE_STYLE);
 
     ws_stream.close(None).await.unwrap();
 
     let v_pb = add_pb(pb, DEFAULT_STYLE, "verify response".to_string());
-    let res = verify_response(msg.unwrap().to_string(), uuid)?;
+    let res = verify_response(&msg.unwrap().to_string(), &uuid)?;
     match res {
         Verified::WrongUuid => {
-            finish_pb(v_pb, "returned wrong uuid".to_string(), ERROR_STYLE);
+            finish_pb(&v_pb, "returned wrong uuid".to_string(), ERROR_STYLE);
             Ok(false)
         }
         Verified::ResponseType(res_type) => match res_type {
             ResponseType::Start => {
-                finish_pb(v_pb, "device started".to_string(), DONE_STYLE);
+                finish_pb(&v_pb, "device started".to_string(), DONE_STYLE);
                 Ok(true)
             }
             ResponseType::Timeout => {
-                finish_pb(v_pb, "ping timed out".to_string(), ERROR_STYLE);
+                finish_pb(&v_pb, "ping timed out".to_string(), ERROR_STYLE);
                 Ok(false)
             }
             ResponseType::NotFound => {
-                finish_pb(v_pb, "unknown uuid".to_string(), ERROR_STYLE);
+                finish_pb(&v_pb, "unknown uuid".to_string(), ERROR_STYLE);
                 Ok(false)
             }
         },
     }
 }
 
-fn get_eta(msg: String, uuid: String) -> Result<u64, CliError> {
+fn get_eta(msg: &str, uuid: &str) -> Result<u64, Error> {
     let spl: Vec<&str> = msg.split('_').collect();
     if (spl[0] != "eta") || (spl[2] != uuid) {
-        return Err(CliError::WsResponse);
+        return Err(Error::WsResponse);
     };
-    Ok(u64::from_str_radix(spl[1], 10).map_err(CliError::Parse)?)
+    Ok(spl[1].parse()?)
 }
 
-fn verify_response(res: String, org_uuid: String) -> Result<Verified, CliError> {
+fn verify_response(res: &str, org_uuid: &str) -> Result<Verified, Error> {
     let spl: Vec<&str> = res.split('_').collect();
     let res_type = spl[0];
     let uuid = spl[1];
@@ -158,12 +148,12 @@ enum ResponseType {
 }
 
 impl ResponseType {
-    fn from(value: &str) -> Result<Self, CliError> {
+    fn from(value: &str) -> Result<Self, Error> {
         match value {
             "start" => Ok(ResponseType::Start),
             "timeout" => Ok(ResponseType::Timeout),
             "notfound" => Ok(ResponseType::NotFound),
-            _ => Err(CliError::WsResponse),
+            _ => Err(Error::WsResponse),
         }
     }
 }