src/appstate.rs

@@ -4,7 +4,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use log::{debug, error, trace};
+use log::{debug, trace};
 use serde::{Deserialize, Serialize};
 
 use super::{
@@ -14,93 +14,46 @@ use super::{
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct AppState {
-    #[serde(skip)]
-    file_name: PathBuf,
-
     alias: Alias,
     share: Share,
-    files: Vec<FileState>,
+    checked: Vec<FileChecked>,
+    uploading: Vec<FileUploading>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-enum FileState {
-    C(FileChecked),
-    U(FileUploading),
+fn get_cachefile(args: &Cli) -> Option<PathBuf> {
+    let file_name: PathBuf = dirs_next::cache_dir()?
+        .join("shrupl")
+        .join(format!("{}.json", args.get_hash()));
+
+    trace!("cachefile: {}", file_name.display());
+
+    Some(file_name)
 }
 
 impl AppState {
-    fn cache_dir() -> PathBuf {
-        let dir_name = dirs_next::cache_dir()
-            .expect("could not determine cache directory")
-            .join("shrupl");
-
-        trace!("cachedir: {}", dir_name.display());
-        dir_name
-    }
-
-    fn cache_file(args: &Cli) -> PathBuf {
-        let file_name = Self::cache_dir().join(format!("{}.json", args.get_hash()));
-
-        trace!("cachefile: {}", file_name.display());
-        file_name
-    }
-
     fn load(file_name: impl AsRef<Path>) -> io::Result<Self> {
         let content = fs::read_to_string(file_name)?;
         serde_json::from_str(&content).map_err(io::Error::other)
     }
 
+    fn save(&self, file_name: impl AsRef<Path>) -> io::Result<()> {
+        let json = serde_json::to_string_pretty(self).map_err(io::Error::other)?;
+        let mut file = fs::File::create(file_name)?;
+        file.write_all(json.as_bytes())?;
+
+        Ok(())
+    }
+
     pub fn try_resume(args: &Cli) -> Option<Self> {
-        let file_name = Self::cache_file(args);
+        let file_name = get_cachefile(args)?;
+
+        // let content = fs::read_to_string(&file_name).ok()?;
+        // serde_json::from_str(&content)
+        //     .inspect_err(|e| debug!("could not resume from {}: {e}", &file_name.display()))
+        //     .ok()
 
         Self::load(&file_name)
             .inspect_err(|e| debug!("could not resume from {}: {e}", file_name.display()))
-            .map(|state| {
-                debug!("successfully loaded AppState");
-
-                Self {
-                    file_name,
-                    alias: state.alias,
-                    share: state.share,
-                    files: state.files,
-                }
-            })
             .ok()
     }
-
-    pub fn from_args(args: &Cli, agent: &ureq::Agent) -> Option<Self> {
-        let file_name = Self::cache_file(args);
-        let alias = args.get_alias();
-
-        let share = Share::create(agent, &alias, args.get_share_request())
-            .inspect_err(|e| error!("could not create Share: {e}"))
-            .ok()?;
-
-        let files: Vec<_> = args.files.clone().into_iter().map(FileState::C).collect();
-
-        Some(Self {
-            file_name,
-            alias,
-            share,
-            files,
-        })
-    }
-
-    pub fn save(&self) -> io::Result<()> {
-        fs::create_dir_all(Self::cache_dir())?;
-
-        let json = serde_json::to_string_pretty(self).map_err(io::Error::other)?;
-        let mut file = fs::File::create(&self.file_name)?;
-        file.write_all(json.as_bytes())?;
-
-        trace!("successfully saved AppState");
-        Ok(())
-    }
-
-    pub fn clear(self) -> io::Result<()> {
-        fs::remove_file(self.file_name)?;
-
-        trace!("successfully cleared AppState");
-        Ok(())
-    }
 }

src/main.rs

@@ -22,24 +22,9 @@ fn main() {
         .build()
         .into();
 
-    let state = AppState::try_resume(&args)
-        .map(|state| {
-            info!("loaded state: {state:?}");
-
-            state
-        })
-        .or_else(|| AppState::from_args(&args, &agent))
-        .unwrap_or_else(|| {
-            error!("could not create new state from cli arguments: {args:?}");
-
-            std::process::exit(1);
-        });
-
-    info!("continuing with state: {state:?}");
-    state.save().unwrap();
-    // state.clear().unwrap();
-
-    return;
+    if let Some(state) = AppState::try_resume(&args) {
+        info!("state: {state:?}");
+    }
 
     let alias = args.get_alias();
     let share = Share::create(&agent, &alias, args.get_share_request()).unwrap();