impl save and dry run

pttodoer/src/main.rs

@@ -6,6 +6,7 @@ use chrono::naive::NaiveDateTime;
 use regex::Regex;
 use croner;
 use clap::Parser;
+use std::io::Write;
 
 fn main() {
    let flags = Flags::new();
@@ -19,12 +20,11 @@ fn main() {
             None => Task::from_string(s),
          };
          db.0[0].tasks.0.push(t);
-         // TODO save
       },
       _ => {},
    };
 
-   println!("{}", db.due().to_string());
+   db.save(flags.dry_run).expect("failed to save");
 }
 
 #[derive(Debug, Parser)]
@@ -40,6 +40,9 @@ struct Flags {
 
    #[arg(short = 'e', long = "edit", default_value="false")]
    edit: bool,
+
+   #[arg(short = 'd', long = "dry-run", default_value="false")]
+   dry_run: bool,
 }
 
 impl Flags {
@@ -106,6 +109,13 @@ impl DB {
       }
       result
    }
+
+   pub fn save(&self, dry_run: bool) -> Result<(), String> {
+      for i in &self.0 {
+         i.save(dry_run)?;
+      }
+      Ok(())
+   }
 }
 
 #[cfg(test)]
@@ -146,10 +156,7 @@ pub struct TasksAndMetadata {
 
 impl TasksAndMetadata {
    pub fn new(file: String) -> Result<TasksAndMetadata, String> {
-      let version = match std::fs::metadata(file.clone()) {
-         Ok(m) => Ok(TS::from_system_time(m.modified().unwrap())),
-         Err(msg) => Err(format!("couldnt get version from {}: {}", file, msg)),
-      }?;
+      let version = file_version(file.clone())?;
       match Tasks::from_file(file.clone()) {
          Ok(tasks) => Ok(TasksAndMetadata{
             tasks: tasks,
@@ -159,6 +166,60 @@ impl TasksAndMetadata {
          Err(msg) => Err(msg),
       }
    }
+
+   pub fn save(&self, dry_run: bool) -> Result<(), String> {
+      let version = file_version(self.file.clone())?;
+      let mut file = self.file.clone();
+      if version != self.version {
+         file = format!("{}.{}", &self.file, &self.version.to_string());
+      }
+
+      self.save_as(file.clone(), dry_run)?;
+
+      match file == self.file {
+         true => Ok(()),
+         false => Err(format!("{} has been updated", self.file)),
+      }
+   }
+
+   fn save_as(&self, file: String, dry_run: bool) -> Result<(), String> {
+      match dry_run {
+         true => {
+            match &file == &self.file {
+               true => eprintln!("# {}", &file),
+               false => eprintln!("# {} <- {}", &file, &self.file),
+            };
+            eprintln!("{}", self.tasks.to_string());
+            Ok(())
+         },
+         false => {
+            match std::fs::File::create(&file) {
+               Ok(mut f) => {
+                  match f.write_all(self.tasks.to_string().as_bytes()) {
+                     Ok(_) => Ok(()),
+                     Err(msg) => Err(format!("failed to write {}: {}", file, msg)),
+                  }
+               },
+               Err(msg) => Err(format!("failed to create {}: {}", file, msg)),
+            }
+         },
+      }
+   }
+
+   //fn debug(&self) -> String {
+   //   format!(
+   //      "# {}\n{}",
+   //      self.file,
+   //      self.tasks.to_string(),
+   //   )
+   //}
+}
+
+fn file_version(file: String) -> Result<TS, String> {
+   match std::fs::metadata(file.clone()) {
+      Ok(m) => Ok(TS::from_system_time(m.modified().unwrap())),
+      Err(msg) => Err(format!("couldnt get version from {}: {}", file, msg)),
+   }
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
@@ -174,7 +235,10 @@ impl Tasks {
          Ok(f) => Ok(f),
          Err(msg) => Err(format!("could not open {}: {}", path, msg)),
       }?;
-      Tasks::from_reader(r)
+      match Tasks::from_reader(r) {
+         Ok(tasks) => Ok(tasks),
+         Err(msg) => Err(format!("failed to load from {}: {}", path, msg)),
+      }
    }
 
    pub fn from_reader(r: impl std::io::Read) -> Result<Tasks, String> {
@@ -772,6 +836,7 @@ mod test_duration {
 }
 
 #[derive(Debug)]
+#[derive(PartialEq)]
 struct TS(u64);
 
 impl TS {

pttodoer/src/testdata/.mvp.yaml.done

@@ -1,4 +1,4 @@
 - todo: a b and c
-  schedule: * * * * *
+  schedule: '* * * * *'
   ts: 123
 - d e f