Implement Reconcile for MaybeMissing

autosurgeon/src/hydrate.rs

@@ -298,7 +298,7 @@ impl<T> HydrateResultExt<Option<T>> for Result<Option<T>, HydrateError> {
 /// Note that this can be combined with `Option<T>` to get both behaviours
 ///
 /// ```rust
-/// # use autosurgeon::{Hydrate, hydrate::MaybeMissing};
+/// # use autosurgeon::{Hydrate, MaybeMissing};
 /// # use automerge::transaction::Transactable;
 /// let mut doc = automerge::AutoCommit::new();
 /// let name = MaybeMissing::<Option<String>>::hydrate(&doc, &automerge::ROOT, "name".into()).unwrap();
@@ -332,6 +332,17 @@ impl<T: Hydrate> Hydrate for MaybeMissing<T> {
     }
 }
 
+impl<T: crate::Reconcile> crate::Reconcile for MaybeMissing<T> {
+    type Key<'a> = T::Key<'a>;
+
+    fn reconcile<R: crate::Reconciler>(&self, reconciler: R) -> Result<(), R::Error> {
+        match self {
+            Self::Missing => Ok(()),
+            Self::Present(val) => val.reconcile(reconciler),
+        }
+    }
+}
+
 impl<T> MaybeMissing<T> {
     pub fn unwrap_or_else<F>(self, f: F) -> T
     where

autosurgeon/src/lib.rs

@@ -459,7 +459,7 @@ mod doc;
 pub use doc::{Doc, ReadDoc};
 pub mod hydrate;
 #[doc(inline)]
-pub use hydrate::{hydrate, hydrate_path, hydrate_prop, Hydrate, HydrateError};
+pub use hydrate::{hydrate, hydrate_path, hydrate_prop, Hydrate, HydrateError, MaybeMissing};
 pub mod reconcile;
 #[doc(inline)]
 pub use reconcile::{

autosurgeon/src/reconcile.rs

@@ -1093,4 +1093,49 @@ mod tests {
             }}
         );
     }
+
+    struct Foo {
+        bar: crate::hydrate::MaybeMissing<String>,
+    }
+
+    impl crate::Reconcile for Foo {
+        type Key<'a> = NoKey;
+
+        fn reconcile<R: Reconciler>(&self, mut reconciler: R) -> Result<(), R::Error> {
+            let mut map = reconciler.map()?;
+            map.put("bar", &self.bar)?;
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn reconcile_maybe_missing_present() {
+        let mut doc = automerge::AutoCommit::new();
+        reconcile(
+            &mut doc,
+            &Foo {
+                bar: crate::MaybeMissing::Present("baz".to_string()),
+            },
+        )
+        .unwrap();
+        let val = doc.get(&automerge::ROOT, "bar").unwrap().unwrap();
+        assert_eq!(
+            val.0,
+            automerge::Value::Scalar(std::borrow::Cow::Owned(ScalarValue::Str("baz".into())))
+        );
+    }
+
+    #[test]
+    fn reconcile_maybe_missing_not_present() {
+        let mut doc = automerge::AutoCommit::new();
+        reconcile(
+            &mut doc,
+            &Foo {
+                bar: crate::MaybeMissing::Missing,
+            },
+        )
+        .unwrap();
+        let val = doc.get(&automerge::ROOT, "bar").unwrap();
+        assert!(val.is_none());
+    }
 }