automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/tests/block_tests.rs

@@ -0,0 +1,887 @@
+use std::sync::Arc;
+
+use automerge::{
+    hydrate_list, hydrate_map, hydrate_text,
+    iter::Span,
+    marks::{ExpandMark, Mark, UpdateSpansConfig},
+    transaction::Transactable,
+    AutoCommit, ObjType, Patch, PatchAction, Prop, ReadDoc, ScalarValue, Value, ROOT,
+};
+use test_log::test;
+
+fn markset(values: Vec<(&'static str, ScalarValue)>) -> Option<Arc<automerge::marks::MarkSet>> {
+    Some(Arc::new(
+        values
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), v))
+            .collect::<automerge::marks::MarkSet>(),
+    ))
+}
+
+#[test]
+fn update_blocks_change_block_properties() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    let block1 = doc.split_block(&text, 0).unwrap();
+    doc.update_object(
+        &block1,
+        &hydrate_map! {
+            "parents" => hydrate_list![],
+            "type" => "ordered-list-item",
+            "attrs" => hydrate_map!{}
+        }
+        .into(),
+    )
+    .unwrap();
+    doc.splice_text(&text, 1, 0, "item 1").unwrap();
+    let block2 = doc.split_block(&text, 7).unwrap();
+    doc.update_object(
+        &block2,
+        &hydrate_map! {
+            "parents" => hydrate_list![],
+            "type" => "ordered-list-item",
+            "attrs" => hydrate_map!{}
+        }
+        .into(),
+    )
+    .unwrap();
+    doc.splice_text(&text, 8, 0, "item 2").unwrap();
+
+    doc.update_diff_cursor();
+
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        [
+            Span::Block(hydrate_map! {
+                "type" => "paragraph",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "item 1".into(),
+                marks: Default::default(),
+            },
+            Span::Block(hydrate_map! {
+                "type" => "unordered-list-item",
+                "parents" => hydrate_list!["ordered-list-item"],
+                "attrs" => hydrate_map!{
+                    "key" => 1,
+                },
+            }),
+            Span::Text {
+                text: "item 2".into(),
+                marks: Default::default(),
+            },
+        ],
+    )
+    .unwrap();
+
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Block(hydrate_map! {
+                "type" => "paragraph",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "item 1".into(),
+                marks: Default::default()
+            },
+            Span::Block(hydrate_map! {
+                "type" => "unordered-list-item",
+                "parents" => hydrate_list!["ordered-list-item"],
+                "attrs" => hydrate_map!{"key" => 1}
+            }),
+            Span::Text {
+                text: "item 2".into(),
+                marks: Default::default()
+            },
+        ]
+    );
+}
+
+#[test]
+fn update_blocks_updates_text() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    let _block1 = doc.split_block(&text, 0).unwrap();
+    doc.splice_text(&text, 1, 0, "first thing").unwrap();
+    let _block2 = doc.split_block(&text, 12).unwrap();
+    doc.splice_text(&text, 13, 0, "second thing").unwrap();
+
+    doc.update_diff_cursor();
+
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        [
+            Span::Block(hydrate_map! {
+                "type" => "ordered-list-item",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "the first thing".into(),
+                marks: Default::default(),
+            },
+            Span::Block(hydrate_map! {
+                "type" => "paragraph",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "the things are done".into(),
+                marks: Default::default(),
+            },
+        ],
+    )
+    .unwrap();
+
+    //let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Block(hydrate_map! {
+                "type" => "ordered-list-item",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "the first thing".into(),
+                marks: Default::default()
+            },
+            Span::Block(hydrate_map! {
+                "type" => "paragraph",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "the things are done".into(),
+                marks: Default::default()
+            },
+        ]
+    );
+}
+
+#[test]
+fn update_blocks_updates_marks() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    doc.splice_text(&text, 0, 0, "onetwo").unwrap();
+    let _block2 = doc.split_block(&text, 6).unwrap();
+    doc.splice_text(&text, 7, 0, "threefour").unwrap();
+
+    doc.update_diff_cursor();
+
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        [
+            Span::Text {
+                text: "one".into(),
+                marks: Default::default(),
+            },
+            Span::Text {
+                text: "two".into(),
+                marks: markset(vec![("bold", true.into())]),
+            },
+            Span::Block(hydrate_map! {}),
+            Span::Text {
+                text: "three".into(),
+                marks: markset(vec![("bold", true.into())]),
+            },
+            Span::Text {
+                text: "four".into(),
+                marks: Default::default(),
+            },
+            Span::Block(hydrate_map! {}),
+        ],
+    )
+    .unwrap();
+
+    //let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Text {
+                text: "one".into(),
+                marks: Default::default()
+            },
+            Span::Text {
+                text: "two".into(),
+                marks: markset(vec![("bold", true.into())])
+            },
+            Span::Block(hydrate_map! {}),
+            Span::Text {
+                text: "three".into(),
+                marks: markset(vec![("bold", true.into())])
+            },
+            Span::Text {
+                text: "four".into(),
+                marks: Default::default()
+            },
+            Span::Block(hydrate_map! {}),
+        ],
+    );
+}
+
+#[test]
+fn update_blocks_noop() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    let block1 = doc.split_block(&text, 0).unwrap();
+    doc.update_object(
+        &block1,
+        &hydrate_map! {
+            "parents" => hydrate_list![],
+            "type" => "ordered-list-item",
+            "attrs" => hydrate_map!{}
+        }
+        .into(),
+    )
+    .unwrap();
+    doc.splice_text(&text, 1, 0, "item 1").unwrap();
+
+    doc.update_diff_cursor();
+
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        [
+            Span::Block(hydrate_map! {
+                "type" => "ordered-list-item",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "item 1".into(),
+                marks: Default::default(),
+            },
+        ],
+    )
+    .unwrap();
+
+    let patches = doc.diff_incremental();
+    assert_eq!(patches.len(), 0, "expected no patches");
+}
+
+#[test]
+fn update_blocks_updates_text_and_blocks_at_once() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    //let block1 = doc.split_block(&text, 0, NewBlock::new("paragraph"))
+    let block1 = doc.split_block(&text, 0).unwrap();
+    doc.update_object(
+        &block1,
+        &hydrate_map! {
+            "parents" => hydrate_list![],
+            "type" => "paragraph",
+            "attrs" => hydrate_map!{}
+        }
+        .into(),
+    )
+    .unwrap();
+    doc.splice_text(&text, 1, 0, "hello world").unwrap();
+
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        vec![
+            Span::Block(hydrate_map! {
+                "type" => "unordered-list-item",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            Span::Text {
+                text: "goodbye world".into(),
+                marks: Default::default(),
+            },
+        ],
+    )
+    .unwrap();
+
+    let spans_after = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans_after,
+        vec![
+            automerge::iter::Span::Block(hydrate_map! {
+                "type" => "unordered-list-item",
+                "parents" => hydrate_list![],
+                "attrs" => hydrate_map!{}
+            }),
+            automerge::iter::Span::Text {
+                text: "goodbye world".into(),
+                marks: None
+            },
+        ]
+    );
+}
+
+#[test]
+fn text_complex_block_properties() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    //let block = doc.split_block(&text, 0, NewBlock::new("ordered-list-item"))
+    //.unwrap();
+    let block1 = doc.split_block(&text, 0).unwrap();
+    doc.update_object(
+        &block1,
+        &hydrate_map! {
+            "type" => hydrate_text!("ordered-list-item"),
+            "parents" => hydrate_list![hydrate_text!("div")],
+        }
+        .into(),
+    )
+    .unwrap();
+
+    let (text_obj, text_id) = doc.get(&block1, "type").unwrap().unwrap();
+    assert_eq!(text_obj, automerge::Value::Object(automerge::ObjType::Text));
+    let value = doc.text(text_id).unwrap();
+    assert_eq!(value, "ordered-list-item");
+
+    let (list_obj, list_id) = doc.get(&block1, "parents").unwrap().unwrap();
+    assert_eq!(list_obj, automerge::Value::Object(automerge::ObjType::List));
+    let len = doc.length(&list_id);
+    assert_eq!(len, 1);
+    let (elem, elem_id) = doc.get(&list_id, 0).unwrap().unwrap();
+    assert_eq!(elem, automerge::Value::Object(automerge::ObjType::Text));
+    let elem_text = doc.text(elem_id).unwrap();
+    assert_eq!(elem_text, "div");
+}
+
+#[test]
+fn update_spans_delete_attribute() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    //let block = doc.split_block(&text, 0, NewBlock::new("ordered-list-item"))
+    //.unwrap();
+    let block1 = doc.split_block(&text, 0).unwrap();
+    doc.update_object(
+        &block1,
+        &hydrate_map! {
+            "type" => hydrate_text!("ordered-list-item"),
+            "parents" => hydrate_list![hydrate_text!("div")],
+        }
+        .into(),
+    )
+    .unwrap();
+
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        [Span::Block(hydrate_map! {
+            "type" => "ordered-list-item",
+            "parents" => hydrate_list![],
+        })],
+    )
+    .unwrap();
+
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![automerge::iter::Span::Block(hydrate_map! {
+            "type" => "ordered-list-item",
+            "parents" => hydrate_list![],
+        })]
+    );
+}
+
+#[test]
+fn marks_on_spans_respect_heads() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    doc.splice_text(&text, 0, 0, "hello world").unwrap();
+
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 0, 5),
+        ExpandMark::After,
+    )
+    .unwrap();
+
+    let heads = doc.get_heads();
+
+    doc.mark(
+        &text,
+        Mark::new("italic".to_string(), true, 5, 11),
+        ExpandMark::After,
+    )
+    .unwrap();
+
+    let spans = doc.spans_at(&text, &heads).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Text {
+                text: "hello".to_string(),
+                marks: markset(vec![("bold", ScalarValue::Boolean(true))]),
+            },
+            Span::Text {
+                text: " world".to_string(),
+                marks: None,
+            }
+        ]
+    );
+}
+
+#[test]
+fn marks_in_spans_cross_block_markers() {
+    let mut doc = AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    doc.splice_text(&text, 0, 0, "lix").unwrap();
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 0, 3),
+        ExpandMark::After,
+    )
+    .unwrap();
+    let _block = doc.split_block(&text, 1).unwrap();
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+
+    assert_eq!(
+        spans,
+        vec![
+            Span::Text {
+                text: "l".to_string(),
+                marks: markset(vec![("bold", true.into())])
+            },
+            Span::Block(hydrate_map! {}),
+            Span::Text {
+                text: "ix".to_string(),
+                marks: markset(vec![("bold", true.into())])
+            },
+        ]
+    );
+}
+
+#[test]
+fn test_mark_behavior_on_delete_insert() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    // Insert text with a bold mark
+    doc.splice_text(&text, 0, 0, "hello").unwrap();
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 0, 5),
+        ExpandMark::Both,
+    )
+    .unwrap();
+
+    // Delete the text and insert new text at the same position
+    doc.splice_text(&text, 0, 5, "").unwrap();
+    doc.splice_text(&text, 0, 0, "hi").unwrap();
+
+    // Check what marks are present
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    eprintln!("After delete and insert: {:?}", spans);
+
+    // The bold mark should not apply to the new text
+    assert_eq!(
+        spans,
+        vec![Span::Text {
+            text: "hi".to_string(),
+            marks: None
+        }]
+    );
+}
+
+#[test]
+fn spans_consolidates_marks_which_are_empty_due_to_deleted_marks() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    // Insert text with a bold mark
+    doc.splice_text(&text, 0, 0, "hello middle world").unwrap();
+
+    // Bold up to the second 'd' in middle
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 0, 9),
+        ExpandMark::None,
+    )
+    .unwrap();
+    // Italic from the second 'd' in middle to the end
+    doc.mark(
+        &text,
+        Mark::new("italic".to_string(), true, 9, 18),
+        ExpandMark::None,
+    )
+    .unwrap();
+
+    // Now delete the bold range on middle
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), ScalarValue::Null, 6, 9),
+        ExpandMark::None,
+    )
+    .unwrap();
+    // And delete the italic range on middle
+    doc.mark(
+        &text,
+        Mark::new("italic".to_string(), ScalarValue::Null, 9, 12),
+        ExpandMark::None,
+    )
+    .unwrap();
+
+    // Check what marks are present
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Text {
+                text: "hello ".to_string(),
+                marks: markset(vec![("bold", true.into())])
+            },
+            Span::Text {
+                text: "middle".to_string(),
+                marks: None
+            },
+            Span::Text {
+                text: " world".to_string(),
+                marks: markset(vec![("italic", true.into())])
+            },
+        ]
+    );
+}
+
+#[test]
+fn spans_consolidates_marks_with_deleted_marks_followed_by_empty_marks() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    doc.splice_text(&text, 0, 0, "hello world").unwrap();
+
+    // Bold world
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 0, 6),
+        ExpandMark::None,
+    )
+    .unwrap();
+    // Now unbold it
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), ScalarValue::Null, 0, 6),
+        ExpandMark::None,
+    )
+    .unwrap();
+
+    // Check what marks are present
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![Span::Text {
+            text: "hello world".to_string(),
+            marks: None
+        },]
+    );
+}
+
+#[test]
+fn spans_consolidates_marks_with_empty_marks_followed_by_deleted_marks() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    doc.splice_text(&text, 0, 0, "hello world").unwrap();
+
+    // Bold world
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 6, 11),
+        ExpandMark::None,
+    )
+    .unwrap();
+    // Now unbold it
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), ScalarValue::Null, 6, 11),
+        ExpandMark::None,
+    )
+    .unwrap();
+
+    // Check what marks are present
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![Span::Text {
+            text: "hello world".to_string(),
+            marks: None
+        },]
+    );
+}
+
+#[test]
+fn update_spans_diffs_marks() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    // Initial text with some marks
+    doc.splice_text(&text, 0, 0, "hello world").unwrap();
+    doc.mark(
+        &text,
+        Mark::new("bold".to_string(), true, 0, 5),
+        ExpandMark::Both,
+    )
+    .unwrap();
+
+    // Update spans with different marks
+    doc.update_spans(
+        &text,
+        UpdateSpansConfig::default(),
+        [
+            Span::Text {
+                text: "hello".into(),
+                marks: markset(vec![("italic", true.into())]),
+            },
+            Span::Text {
+                text: " ".into(),
+                marks: Default::default(),
+            },
+            Span::Text {
+                text: "world".into(),
+                marks: markset(vec![("bold", true.into()), ("italic", true.into())]),
+            },
+        ],
+    )
+    .unwrap();
+
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Text {
+                text: "hello".to_string(),
+                marks: markset(vec![("italic", true.into())])
+            },
+            Span::Text {
+                text: " ".to_string(),
+                marks: None
+            },
+            Span::Text {
+                text: "world".to_string(),
+                marks: markset(vec![("bold", true.into()), ("italic", true.into())])
+            },
+        ]
+    );
+}
+
+#[test]
+fn update_spans_uses_expand_config() {
+    let mut doc = automerge::AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    // Create custom config with different expand behaviors
+    let config = UpdateSpansConfig::default()
+        .with_default_expand(ExpandMark::None)
+        .with_mark_expand("bold", ExpandMark::After);
+
+    // Apply marks with the config
+    doc.update_spans(
+        &text,
+        config,
+        [
+            Span::Text {
+                text: "hello".into(),
+                marks: markset(vec![("bold", true.into())]),
+            },
+            Span::Text {
+                text: " world".into(),
+                marks: Default::default(),
+            },
+        ],
+    )
+    .unwrap();
+
+    // Insert text after "hello" - should be marked because ExpandMark::After
+    doc.splice_text(&text, 5, 0, "!").unwrap();
+
+    // Insert text before "hello" - should NOT be marked because ExpandMark::After
+    doc.splice_text(&text, 0, 0, "Oh ").unwrap();
+
+    let spans = doc.spans(&text).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans,
+        vec![
+            Span::Text {
+                text: "Oh ".to_string(),
+                marks: None
+            },
+            Span::Text {
+                text: "hello!".to_string(),
+                marks: markset(vec![("bold", true.into())])
+            },
+            Span::Text {
+                text: " world".to_string(),
+                marks: None
+            },
+        ]
+    );
+}
+
+#[test]
+fn diff_emits_block_updates() {
+    let mut doc = AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+    // Disable patch log to make sure we are testing the diff not the patch log
+    doc.reset_diff_cursor();
+    let block = doc.split_block(&text, 0).unwrap();
+    let parents = doc.put_object(&block, "parents", ObjType::List).unwrap();
+
+    let heads = doc.get_heads();
+    let patches = doc.diff(&[], &heads);
+
+    let expected_patches = vec![
+        Patch {
+            action: automerge::PatchAction::PutMap {
+                key: "text".to_string(),
+                value: (Value::Object(ObjType::Text), text.clone()),
+                conflict: false,
+            },
+            path: vec![],
+            obj: ROOT,
+        },
+        Patch {
+            action: automerge::PatchAction::Insert {
+                index: 0,
+                values: [(Value::Object(ObjType::Map), block.clone(), false)]
+                    .into_iter()
+                    .collect(),
+            },
+            path: vec![(ROOT, Prop::Map("text".to_string()))],
+            obj: text.clone(),
+        },
+        Patch {
+            action: automerge::PatchAction::PutMap {
+                key: "parents".to_string(),
+                value: (Value::Object(ObjType::List), parents.clone()),
+                conflict: false,
+            },
+            path: vec![
+                (ROOT, Prop::Map("text".to_string())),
+                (text.clone(), Prop::Seq(0)),
+            ],
+            obj: block,
+        },
+    ];
+
+    assert_eq!(patches, expected_patches);
+
+    // Now make a new change to the document so that diff has to use clocks,
+    // which exercises a different code path
+    doc.splice_text(&text, 0, 0, "hello world").unwrap();
+
+    let patches = doc.diff(&[], &heads);
+    assert_eq!(patches, expected_patches);
+}
+
+#[test]
+fn merge_produces_block_insertion_diffs() {
+    let mut doc = AutoCommit::new();
+    let text = doc.put_object(ROOT, "text", ObjType::Text).unwrap();
+
+    let mut doc2 = doc.fork();
+
+    let block1 = doc.split_block(&text, 0).unwrap();
+
+    doc2.update_diff_cursor();
+    let heads_before = doc2.get_heads();
+    doc2.merge(&mut doc).unwrap();
+    let heads_after = doc2.get_heads();
+    let patches = doc2.diff(&heads_before, &heads_after);
+    for patch in &patches {
+        println!("{:?}", patch);
+    }
+
+    let patch = patches[0].clone();
+    assert_eq!(patch.obj, text);
+    assert_eq!(
+        patch.action,
+        PatchAction::Insert {
+            index: 0,
+            values: vec![(Value::Object(ObjType::Map), block1, false)]
+                .into_iter()
+                .collect()
+        }
+    );
+}
+
+#[test]
+fn test_splice_with_mark() {
+    // Reproduces the issue in https://github.com/automerge/automerge/issues/935
+    // The problem was that replacing some marked text using `splice_text` would
+    // not preserve marks around the text if the mark boundaries were on the ends
+    // of the text that was being replaced.
+
+    let s1 = "abc";
+    let m1 = automerge::marks::Mark::new(
+        "some_nonexpanding_mark_type".into(),
+        "marked".to_string(),
+        1,
+        2,
+    );
+    let m2 = automerge::marks::Mark::new(
+        "some_expanding_mark_type".into(),
+        "marked".to_string(),
+        1,
+        2,
+    );
+    let mut doc = AutoCommit::new();
+    let txt = doc
+        .put_object(&automerge::ROOT, "txt", ObjType::Text)
+        .unwrap();
+    doc.splice_text(&txt, 0, 0, s1).unwrap();
+    doc.mark(&txt, m1, automerge::marks::ExpandMark::None)
+        .unwrap();
+    doc.mark(&txt, m2, automerge::marks::ExpandMark::Both)
+        .unwrap();
+
+    let spans_before = doc.spans(&txt).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans_before,
+        vec![
+            Span::Text {
+                text: "a".to_string(),
+                marks: None
+            },
+            Span::Text {
+                text: "b".to_string(),
+                marks: markset(vec![
+                    ("some_nonexpanding_mark_type", "marked".into()),
+                    ("some_expanding_mark_type", "marked".into())
+                ])
+            },
+            Span::Text {
+                text: "c".to_string(),
+                marks: None
+            },
+        ]
+    );
+
+    doc.splice_text(&txt, 1, 1, "d").unwrap();
+
+    let spans_after = doc.spans(&txt).unwrap().collect::<Vec<_>>();
+    assert_eq!(
+        spans_after,
+        vec![
+            Span::Text {
+                text: "a".to_string(),
+                marks: None
+            },
+            Span::Text {
+                text: "d".to_string(),
+                marks: markset(vec![("some_expanding_mark_type", "marked".into())])
+            },
+            Span::Text {
+                text: "c".to_string(),
+                marks: None
+            },
+        ]
+    );
+}