persist delta of last snapshot and stage

pttodoest/src/main.rs

@@ -154,7 +154,7 @@ impl File {
     }
 
     pub fn persist_unpersisted_stage(&self) -> Result<(), String> {
-        let events = self.events()?;
+        let old_snapshot = self.events()?.last_snapshot();
         let stage_mod_time = std::fs::metadata(&self.file)
             .unwrap()
             .modified()
@@ -162,29 +162,12 @@ impl File {
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
             .as_secs();
-        let old_persisted: Vec<Delta> = events
-            .0
-            .iter()
-            .filter(|x| x.ts <= stage_mod_time)
-            .map(|x| x.clone())
-            .collect();
-        let old_events = Events(old_persisted);
-        eprintln!(
-            "stage_mod_time = {}, old events = {:?}",
-            stage_mod_time, old_events
-        );
-        let old_snapshot = old_events.snapshot()?;
-        eprintln!(
-            "self.persist_delta_at({:?}, {:?}",
-            old_snapshot,
-            self.stage().unwrap()
-        );
         self.persist_delta_at(old_snapshot, self.stage()?, stage_mod_time)
-        //self.stage_persisted()
     }
 
     pub fn stage_persisted(&self) -> Result<(), String> {
         let persisted_as_snapshot = self.events()?.snapshot()?;
+        self.append(Delta::snapshot(persisted_as_snapshot.clone()))?;
         let plaintext = serde_yaml::to_string(&persisted_as_snapshot).unwrap();
         let mut f = std::fs::File::create(&self.file).expect("failed to open file for writing");
         writeln!(f, "{}", plaintext).expect("failed to write");
@@ -198,9 +181,6 @@ impl File {
 
         let stage = self.stage()?;
 
-        eprintln!("persist delta...");
-        eprintln!(" persisted=before={:?}", &persisted);
-        eprintln!("     stage=aftere={:?}", &stage);
         self.persist_delta(persisted, stage)?;
         Ok(())
     }
@@ -364,12 +344,6 @@ mod test_file {
             f.persist_stage().unwrap();
             assert_eq!(6, f.events().unwrap().0.len());
             assert_eq!(0, f.stage().unwrap().len());
-            eprintln!("persist_stage | events | {:?}", f.events().unwrap().0);
-            eprintln!(
-                "persist_stage | events.snapshot | {:?}",
-                f.events().unwrap().snapshot()
-            );
-            eprintln!("persist_stage | stage | {:?}", f.stage().unwrap());
             tests::file_contains(&d, "plain", "[]");
 
             f.stage_persisted().unwrap();
@@ -536,9 +510,7 @@ mod test_file {
             );
             assert_eq!(0, f.stage().unwrap().len(), "{:?}", f.stage());
 
-            eprintln!("0 | {:?}", f.stage().unwrap());
             f.persist_stage().unwrap();
-            eprintln!("0 | {:?}", f.stage().unwrap());
             assert_eq!(
                 1,
                 f.events().unwrap().0.len(),
@@ -596,6 +568,15 @@ impl Delta {
         }
     }
 
+    pub fn snapshot(tasks: Vec<Task>) -> Delta {
+        Delta {
+            ts: Self::now_time(),
+            op: Op::Snapshot,
+            task: Task(serde_yaml::Value::Null),
+            tasks: Some(tasks),
+        }
+    }
+
     pub fn add(task: Task) -> Delta {
         Self::add_at(task, Self::now_time())
     }
@@ -829,6 +810,16 @@ impl Events {
             .to_string()
     }
 
+    fn last_snapshot(&self) -> Vec<Task> {
+        for event in self.0.iter() {
+            match &event.op {
+                Op::Snapshot => return event.tasks.clone().unwrap(),
+                _ => {}
+            };
+        }
+        vec![]
+    }
+
     fn snapshot(&self) -> Result<Vec<Task>, String> {
         let mut result = vec![];
         for event in self.0.iter() {