fix: add missing tests and exports for prosemirror-transform

- Add test_replace_step.py with ReplaceAroundStep.map tests for wrap/unwrap
- Add removeNodeMark multiple instances test
- Add setBlockType function attrs test
- Add changedRange tests (null, range, multiple steps, deletions)
- Add liftTarget split nodes test
- Export DocAttrStep from prosemirror.transform __init__.py

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sciyoshi

prosemirror/transform/__init__.py

@@ -1,4 +1,5 @@
 from .attr_step import AttrStep
+from .doc_attr_step import DocAttrStep
 from .map import Mapping, MapResult, StepMap
 from .mark_step import AddMarkStep, AddNodeMarkStep, RemoveMarkStep, RemoveNodeMarkStep
 from .replace import (
@@ -24,6 +25,7 @@
     "AddMarkStep",
     "AddNodeMarkStep",
     "AttrStep",
+    "DocAttrStep",
     "MapResult",
     "Mapping",
     "RemoveMarkStep",

tests/prosemirror_transform/tests/test_replace_step.py

@@ -0,0 +1,45 @@
+from prosemirror.test_builder import out
+from prosemirror.test_builder import test_schema as schema
+from prosemirror.transform import Transform, find_wrapping
+
+doc = out["doc"]
+blockquote = out["blockquote"]
+p = out["p"]
+
+
+def test_replace_around_step_map_wrap_insertion():
+    """Wrap steps don't break on insertions at start."""
+    d = doc(p("a"))
+    tr_a = Transform(d)
+    range_ = tr_a.doc.resolve(1).block_range()
+    assert range_ is not None
+    wrappers = find_wrapping(range_, schema.nodes["blockquote"])
+    assert wrappers is not None
+    tr_a.wrap(range_, wrappers)
+
+    tr_b = Transform(d)
+    tr_b.insert(0, p("b"))
+
+    mapped_step = tr_a.steps[0].map(tr_b.mapping)
+    assert mapped_step is not None
+    result = Transform(tr_b.doc).step(mapped_step).doc
+    expected = doc(p("b"), blockquote(p("a")))
+    assert result.eq(expected)
+
+
+def test_replace_around_step_map_unwrap_insertion():
+    """Content inserted at start of unwrap step isn't overwritten."""
+    d = doc(blockquote(p("a")))
+    tr_a = Transform(d)
+    range_ = tr_a.doc.resolve(2).block_range()
+    assert range_ is not None
+    tr_a.lift(range_, 0)
+
+    tr_b = Transform(d)
+    tr_b.insert(2, schema.text("x"))
+
+    mapped_step = tr_a.steps[0].map(tr_b.mapping)
+    assert mapped_step is not None
+    result = Transform(tr_b.doc).step(mapped_step).doc
+    expected = doc(p("xa"))
+    assert result.eq(expected)

tests/prosemirror_transform/tests/test_structure.py

@@ -272,3 +272,39 @@ def test_replace(doc, from_, to, content, open_start, open_end, result):
     slice = Slice(content.content, open_start, open_end) if content else Slice.empty
     tr = Transform(doc).replace(from_, to, slice)
     assert tr.doc.eq(result)
+
+
+def test_lift_target_notices_unliftable_content():
+    s = Schema({
+        "nodes": {
+            "doc": {"content": "section+"},
+            "section": {"content": "heading? p+"},
+            "heading": {"content": "p+"},
+            "p": {"content": "text*"},
+            "text": {"inline": True},
+        },
+    })
+    p_node = s.node("p", None, [s.text("A")])
+    d = s.node(
+        "doc",
+        None,
+        [
+            s.node(
+                "section",
+                None,
+                [s.node("heading", None, [p_node, p_node, p_node]), p_node],
+            ),
+        ],
+    )
+    r1 = d.resolve(3).block_range()
+    assert r1 is not None
+    assert lift_target(r1) is None
+    r2 = d.resolve(6).block_range()
+    assert r2 is not None
+    assert lift_target(r2) is None
+    r3 = d.resolve(3).block_range(d.resolve(6))
+    assert r3 is not None
+    assert lift_target(r3) is None
+    r4 = d.resolve(9).block_range()
+    assert r4 is not None
+    assert lift_target(r4) == 1

tests/prosemirror_transform/tests/test_trans.py

@@ -1171,3 +1171,78 @@ def test_add_node_mark(doc, mark, expect, test_transform):
 )
 def test_remove_node_mark(doc, mark, expect, test_transform):
     test_transform(Transform(doc).remove_node_mark(doc.tag["a"], mark), expect)
+
+
+def test_remove_node_mark_multiple_instances(test_transform):
+    s = Schema({
+        "nodes": {
+            "doc": {"content": "p+", "marks": "comment"},
+            "p": {"content": "text*"},
+            "text": {},
+        },
+        "marks": {"comment": {"excludes": "", "attrs": {"id": {}}}},
+    })
+    d = s.node(
+        "doc",
+        None,
+        [
+            s.node(
+                "p",
+                None,
+                [s.text("abc")],
+                [s.mark("comment", {"id": 1}), s.mark("comment", {"id": 2})],
+            ),
+        ],
+    )
+    test_transform(
+        Transform(d).remove_node_mark(0, s.marks["comment"]),
+        s.node("doc", None, [s.node("p", None, [s.text("abc")])]),
+    )
+
+
+def test_set_block_type_function_attrs(test_transform):
+    d = doc("<a>", h1("a"), p("b"), "<b>")
+    tr = Transform(d).set_block_type(
+        d.tag["a"],
+        d.tag["b"],
+        schema.nodes["heading"],
+        lambda node: {"level": (node.attrs.get("level") or 0) + 1},
+    )
+    test_transform(tr, doc(h2("a"), h1("b")))
+
+
+def test_changed_range_returns_none_when_no_changes():
+    d = doc(p("hello"))
+    tr = Transform(d)
+    assert tr.changed_range() is None
+    tr.add_mark(1, 3, schema.mark("strong"))
+    assert tr.changed_range() is None
+
+
+def test_changed_range_returns_range():
+    d = doc(p("ab"))
+    tr = Transform(d).insert(3, schema.text("c"))
+    ch = tr.changed_range()
+    assert ch is not None
+    assert f"{ch['from']}-{ch['to']}" == "3-4"
+
+
+def test_changed_range_multiple_steps():
+    d = doc(p("ab"))
+    tr = (
+        Transform(d)
+        .insert(3, schema.text("c"))
+        .insert(2, schema.text("d"))
+        .insert(1, schema.text("e"))
+    )
+    ch = tr.changed_range()
+    assert ch is not None
+    assert f"{ch['from']}-{ch['to']}" == "1-6"
+
+
+def test_changed_range_deletions_before_earlier_step():
+    d = doc(p("abcde"))
+    tr = Transform(d).insert(6, schema.text("f")).delete(1, 4)
+    ch = tr.changed_range()
+    assert ch is not None
+    assert f"{ch['from']}-{ch['to']}" == "1-4"