wip - from functions

rust/src/automerge.udl

@@ -112,7 +112,7 @@ dictionary MarkSet {
 interface AMValue {
     Map ( record<string,AMValue> value );
     Scalar ( ScalarValue value );
-    List ( sequence<HydratedList> value );
+    List ( sequence<HydratedListItem> value );
     Text ( HydratedText value );
 };
 
@@ -121,7 +121,7 @@ dictionary HydratedText {
     record<string,ScalarValue> marks;
 };
 
-dictionary HydratedList {
+dictionary HydratedListItem {
     AMValue value;
     record<string,ScalarValue> marks;
     boolean conflict;

rust/src/doc.rs

@@ -7,6 +7,7 @@ use automerge::{transaction::Transactable, ReadDoc};
 use crate::actor_id::ActorId;
 use crate::cursor::Position;
 use crate::mark::{ExpandMark, KeyValue, Mark};
+use crate::span::{Span};
 use crate::patches::Patch;
 use crate::{
     Change, ChangeHash, Cursor, ObjId, ObjType, PathElement, ScalarValue, SyncState, Value,
@@ -514,6 +515,15 @@ impl Doc {
         Ok(())
     }
 
+    pub fn spans(&self, obj: ObjId) -> Result<Vec<Span>, DocError> {
+        let mut doc = self.0.write().unwrap();
+        let obj = am::ObjId::from(obj);
+        let x = doc.spans(obj).unwrap();
+        let y = x
+        .into_iter()
+        .map(am::iter::spans::from);
+    }
+
     pub fn merge(&self, other: Arc<Self>) -> Result<(), DocError> {
         let mut doc = self.0.write().unwrap();
         let mut other = other.0.write().unwrap();

rust/src/lib.rs

@@ -27,4 +27,4 @@ use sync_state::{DecodeSyncStateError, SyncState};
 mod value;
 use value::Value;
 mod span;
-use span::{AMValue, HydratedList, HydratedText, MarkSet, Span};
+use span::{AMValue, HydratedListItem, HydratedText, MarkSet, Span};

rust/src/span.rs

@@ -1,6 +1,6 @@
 use crate::ScalarValue;
 use std::collections::HashMap;
-// use automerge as am;
+use automerge as am;
 
 // maps to am::iter::Span
 // need to create From<> in to convert over
@@ -14,22 +14,57 @@ pub enum Span {
     Block { value: HashMap<String, AMValue> },
 }
 
+// impl From<Span> for am::iter::Spans<'_> {
+//     fn from(value: Span) -> Self {
+//         let inner: [u8; 32] = value.0.try_into().unwrap();
+//         am::ChangeHash(inner)
+//     }
+// }
+
+impl<'a> From<&'a am::iter::Span> for Span {
+    fn from(value: &'a am::iter::Span) -> Self {
+        match value {
+            am::iter::Span::Text( t, m) => Self::Text { text: t.to_string(), marks: Option<Arc<am::marks::MarkSet>>::from() },
+            am::iter::Span::Block( value ) => Self::Block { value: HashMap<String, AMValue>::from(value) }
+        }
+    }
+}
+
+impl<'a> From<&'a am::hydrate::Map> for HashMap<String, AMValue> {
+    fn from(value: &'a am::hydrate::Map) -> Self {
+        let mut new_hash_map:HashMap<String, AMValue> = HashMap::new();
+        // fill in the middle bits...
+        return new_hash_map;
+    }
+}
+
 // loosely maps to am::marks:MarkSet
 // need to create From<> in to convert over
 pub struct MarkSet {
     pub marks: HashMap<String, ScalarValue>,
 }
 
+impl<'a> From<&'a am::marks::MarkSet> for MarkSet {
+    fn from(value: &'a am::marks::MarkSet) -> Self {
+        let mut new_hash:HashMap<String, ScalarValue> = HashMap::new();
+        // iterate through MarkSet, building a hashmap for this MarkSet 
+        for (k, v) in value.iter() {
+            new_hash.insert(k.to_string(), v.into());
+        }
+        Self { marks: new_hash }
+    }
+}
+
 pub enum AMValue {
     Map { value: HashMap<String, AMValue> },
     Scalar { value: ScalarValue },
-    List { value: Vec<HydratedList> },
+    List { value: Vec<HydratedListItem> },
     Text { value: HydratedText },
 }
 
 // loosely maps to am::hydrate::ListValue
 // need to create From<> in to convert over
-pub struct HydratedList {
+pub struct HydratedListItem {
     pub value: AMValue,
     pub marks: HashMap<String, ScalarValue>,
     pub conflict: bool,