need tests for all the edits--like adding a scheduled, deleting a scheduled should add a _doned

pttodoer/src/main.rs

@@ -26,9 +26,8 @@ fn main() {
    };
 
    if flags.edit {
-      db.edit().expect("failed to edit");
+      db = db.edit().expect("failed to edit")
    }
-
    db.save(flags.dry_run).expect("failed to save");
 }
 
@@ -115,7 +114,7 @@ impl DB {
       result
    }
 
-   pub fn edit(&self) -> Result<(), String> {
+   pub fn edit(&self) -> Result<DB, String> {
       let d = TempDir::new(&TS::now().to_string()).expect("failed to create a temp dir");
       for set in &self.0 {
          let base = set.file.split("/").last().unwrap().to_string();
@@ -123,37 +122,81 @@ impl DB {
          set.save_due_as(f.display().to_string())?;
       }
 
-      //std::process::Command::new("/bin/sh")
+      loop {
-      //   .current_dir(d.path())
+         std::process::Command::new("/bin/sh")
-      //   .arg("-c")
+            .current_dir(d.path())
-      //   .arg("vim -p ./*")
+            .arg("-c")
-      //   .spawn()
+            .arg("vim -p ./*")
-      //   .expect("failed to start vim")
+            .spawn()
-      //   .wait()
+            .expect("failed to start vim")
-      //   .expect("failed to vim");
+            .wait()
+            .expect("failed to vim");
+         let mut ok = true;
+         for set in &self.0 {
+            let base = set.file.split("/").last().unwrap().to_string();
+            let f = d.path().join(base);
+            ok = ok && TasksAndMetadata::new(f.display().to_string()).is_ok();
+         }
+         if ok {
+            break;
+         }
+      }
 
+      let mut result = vec![];
       for set in &self.0 {
          let base = set.file.split("/").last().unwrap().to_string();
          let f = d.path().join(base);
-         let edited = TasksAndMetadata::new(f.display().to_string());
 
-         let not_due = set.not_due();
+         let edited = TasksAndMetadata::new(f.display().to_string()).expect("failed to read edited tasks");
+
          let was_due = set.due();
+         let mut now_due = vec![];
+         let mut not_due = set.not_due().tasks.0;
 
-         // for each in was_due
+         for task in &edited.tasks.0 {
-         //    if not in edited
+            if task.is_due() {
-         //       not_due.push
+               eprintln!("now_due.push({:?})", task.clone());
-         // due = []
+               now_due.push(task.clone());
-         // for each in edited
+            } else if !not_due.contains(task) {
-         //    if not due
+               eprintln!("not_due.push({:?})", task.clone());
-         //       not_due.push
+               not_due.push(task.clone());
-         //    else
+            }
-         //       due.push
+         }
-         // all = due + not_due // ordered
+
-         // save to self.0
+         let mut already_due = vec![];
+         let mut already_not_due = vec![];
+         for task in &was_due.tasks.0 {
+            let mut without_ts = task.clone();
+            without_ts.unset("ts".to_string());
+
+            let mut with_ts = task.clone();
+            with_ts.set("ts".to_string(), TS::now().to_string());
+
+            if now_due.contains(&without_ts) {
+            } else if not_due.contains(task) {
+            } else if task.is_due() {
+               eprintln!("already_due.push({:?})", with_ts.clone());
+               already_due.push(with_ts.clone());
+            } else {
+               eprintln!("already_not_due.push({:?})", task.clone());
+               already_not_due.push(task.clone());
+            }
+         }
+
+         let mut new_tasks = Tasks::new();
+         new_tasks.0.extend(now_due);
+         new_tasks.0.extend(already_due);
+         new_tasks.0.extend(not_due);
+         new_tasks.0.extend(already_not_due);
+
+         result.push(TasksAndMetadata::new_with(
+            set.file.clone(),
+            set.version.clone(),
+            new_tasks,
+         ));
       }
 
-      Err("not impl".to_string())
+      Ok(DB{0: result})
    }
 
    pub fn save(&self, dry_run: bool) -> Result<(), String> {
@@ -201,6 +244,14 @@ pub struct TasksAndMetadata {
 }
 
 impl TasksAndMetadata {
+   pub fn new_with(file: String, version: TS, tasks: Tasks) -> TasksAndMetadata {
+      TasksAndMetadata{
+         file: file,
+         version: version,
+         tasks: tasks,
+      }
+   }
+
    pub fn new(file: String) -> Result<TasksAndMetadata, String> {
       let version = file_version(file.clone())?;
       match Tasks::from_file(file.clone()) {
@@ -460,7 +511,7 @@ mod test_tasks {
 }
 
 
-#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq)]
 pub struct Task(serde_yaml::Mapping);
 
 impl Task {
@@ -900,7 +951,7 @@ mod test_duration {
 }
 
 #[derive(Debug, PartialEq, Clone)]
-struct TS(u64);
+pub struct TS(u64);
 
 impl TS {
    fn now() -> TS {

pttodoer/src/testdata/legacy.yaml

@@ -1,17 +1,19 @@
-todo:
 - a
 - todo: b
   schedule: 2000-01-01
-scheduled:
 - c
 - todo: d
   schedule: 2000-02-01
 - todo: e
-  ts: Sun Dec  3 23:29:27 EST 2023
+  schedule: 0 0 1 1 *
-  schedule: '0 0 1 1 *'
+- todo: e3
+  schedule: '* * * * *'
+- todo: e2
+  schedule: 0 0 1 1 *
+  ts: 2024-08-04T19:32Z
 - todo: f
   schedule: 2099-02-02
-done:
+- _done: g
-- g
+- _done:
-- todo: h
+    todo: h
-  ts: Sun Dec  3 23:29:27 EST 2023
+    ts: Sun Dec  3 23:29:27 EST 2023