setting version + fmt

src/config.rs

@@ -28,6 +28,10 @@ impl Config {
         }
     }
 
+    pub fn set_version(&mut self, version: String) {
+        self.version = Some(version)
+    }
+
     pub fn walk<T>(path: T, to: T) -> Result<PathBuf, Error>
     where
         T: AsRef<str>,

src/error.rs

@@ -16,7 +16,7 @@ pub enum Error {
     NoInternetConnection,
     CantCreateDownloadedFile(String),
     CantCreateCursorBytes,
-    CantCopyBytes
+    CantCopyBytes,
 }
 
 impl Debug for Error {

src/main.rs

@@ -10,7 +10,7 @@ async fn main() {
         Ok(c) => Some(c),
         Err(_) => None,
     };
-    let wall = Wall::new(config);
+    let mut wall = Wall::new(config);
 
     match args.command {
         Commands::Set { path } => wall.set(path),

src/source.rs

@@ -1,26 +1,25 @@
-use std::{fs, io};
-use std::io::Cursor;
 use crate::config::Config;
 use crate::error::Error;
 use octocrab as Git;
+use octocrab::models::repos::Release;
 use octocrab::{Octocrab, Page};
 use reqwest::Client as Http;
+use std::io::Cursor;
 use std::sync::Arc;
-use octocrab::models::repos::Release;
+use std::{fs, io};
 
-static DEFAULT_TARGET: &str = "akumarujon/wall-rs-mirror";
 static USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
 
 pub struct Source {
     git: Arc<Octocrab>,
-    client: Http,
+    http: Http,
 }
 
 impl Source {
     pub fn new(_config: Option<Config>) -> Self {
         Self {
             git: Git::instance(),
-            client: Http::builder().user_agent(USER_AGENT).build().unwrap(),
+            http: Http::builder().user_agent(USER_AGENT).build().unwrap(),
         }
     }
 
@@ -32,10 +31,10 @@ impl Source {
             .list()
             .send()
             .await;
-        
+
         let releases = match releases {
             Ok(r) => r,
-            Err(err) => return Err(Error::ReleaseFetchError(err))
+            Err(err) => return Err(Error::ReleaseFetchError(err)),
         };
 
         Ok(releases)
@@ -52,49 +51,47 @@ impl Source {
 
         let releases = match releases {
             Ok(r) => r,
-            Err(err) => return Err(Error::ReleaseFetchError(err))
+            Err(err) => return Err(Error::ReleaseFetchError(err)),
         };
 
         let latest = match releases.items.first() {
             Some(v) => v,
-            None => return Err(Error::NoVersionFound)
+            None => return Err(Error::NoVersionFound),
         };
 
         Ok(latest.tag_name.to_owned())
     }
 
     pub async fn download_file<T>(&self, url: T, dest: T) -> Result<(), Error>
     where
-        T: ToString
+        T: ToString,
     {
-        let response = match reqwest::get(url.to_string()).await {
+        let response = match self.http.get(url.to_string()).send().await {
             Ok(d) => d,
-            Err(_) => return Err(Error::NoInternetConnection)
+            Err(_) => return Err(Error::NoInternetConnection),
         };
 
         let mut file = match std::fs::File::create(dest.to_string().clone()) {
             Ok(f) => f,
-            Err(_) => return Err(Error::CantCreateDownloadedFile(dest.to_string()))
+            Err(_) => return Err(Error::CantCreateDownloadedFile(dest.to_string())),
         };
 
-        let mut content = Cursor::new(
-            match response.bytes().await {
-                Ok(b) => b,
-                Err(_) => return Err(Error::CantCreateCursorBytes)
-            }
-        );
+        let mut content = Cursor::new(match response.bytes().await {
+            Ok(b) => b,
+            Err(_) => return Err(Error::CantCreateCursorBytes),
+        });
 
         match std::io::copy(&mut content, &mut file) {
-            Ok(_) => {},
-            Err(_) => return Err(Error::CantCopyBytes)
+            Ok(_) => {}
+            Err(_) => return Err(Error::CantCopyBytes),
         };
 
         Ok(())
     }
 
     pub fn extract_file<T>(&self, file: T) -> Result<(), Error>
     where
-        T: AsRef<str>
+        T: AsRef<str>,
     {
         let fname = std::path::Path::new(file.as_ref());
         let file = fs::File::open(fname).unwrap();
@@ -145,7 +142,6 @@ impl Source {
             }
         }
 
-
         Ok(())
     }
 }

src/wall.rs

@@ -8,8 +8,6 @@ use std::path::PathBuf;
 use std::process::exit;
 use std::str::FromStr;
 
-static DEFAULT_TARGET: &str = "https://github.com/akumarujon/wall-rs-mirror";
-
 pub struct Wall {
     pub config: Option<Config>,
 }
@@ -107,7 +105,7 @@ impl Wall {
         self.set(first.to_owned())
     }
 
-    pub async fn install(&self, url: Option<String>) -> Result<(), Error> {
+    pub async fn install(&mut self, url: Option<String>) -> Result<(), Error> {
         let mut target = String::new();
         let source = Source::new(None);
 
@@ -119,15 +117,23 @@ impl Wall {
             Some(l) => target.push_str(&l),
             None => {
                 let mut versions = source.get_latest_version().await.unwrap();
-                versions = format!("https://github.com/akumarujon/wall-rs-mirror/releases/download/{}/assets.zip", versions);
+                versions = format!(
+                    "https://github.com/akumarujon/wall-rs-mirror/releases/download/{}/assets.zip",
+                    versions
+                );
 
+                self.config.as_mut().unwrap().set_version(versions.clone());
                 target.push_str(&versions)
-            },
+            }
         };
 
         const FILENAME: &str = "assets.zip";
 
-        source.download_file(target, FILENAME.to_string()).await.unwrap();
+        source
+            .download_file(target, FILENAME.to_string())
+            .await
+            .unwrap();
+
         source.extract_file(FILENAME).unwrap();
 
         Ok(())
@@ -136,6 +142,10 @@ impl Wall {
     pub fn auto(&self) {
         dbg!("Trying to setup wallpaper automatically!");
     }
+
+    pub fn exit(&self) {
+        self.config.as_ref().unwrap().write("").unwrap()
+    }
 }
 
 #[cfg(test)]