Struct Document 

pub struct Document { /* private fields */ }

An owned Tiptap document (its root node, usually type: "doc").

Derefs to the root Node, so all query/mutation methods are available directly on a Document.

Implementations

impl Document

pub fn new(root: Node) -> Self

Wrap an existing root node.

pub fn from_json_str(s: &str) -> Result<Self>

Parse from a JSON string.

use tiptap_rusty_parser::Document;
let d = Document::from_json_str(r#"{"type":"doc","content":[]}"#).unwrap();
assert_eq!(d.node_type.as_deref(), Some("doc"));

pub fn from_value(value: Value) -> Result<Self>

Parse from a serde_json::Value.

pub fn from_reader(reader: impl Read) -> Result<Self>

Parse from any reader.

pub fn to_json_str(&self) -> Result<String>

Serialize to a compact JSON string.

pub fn to_string_pretty(&self) -> Result<String>

Serialize to a pretty JSON string.

pub fn to_value(&self) -> Result<Value>

Serialize to a serde_json::Value.

pub fn root(&self) -> &Node

Borrow the root node.

pub fn root_mut(&mut self) -> &mut Node

Mutably borrow the root node.

pub fn into_root(self) -> Node

Consume into the root node.

pub fn diff(&self, other: &Document) -> Vec<Change>

Structural diff from this document to other. See Node::diff.

pub fn apply(&mut self, changes: &[Change]) -> Result<(), ApplyError>

Apply a Change list in place. See crate::apply.

pub fn invert(&self, changes: &[Change]) -> Result<Vec<Change>, ApplyError>

Invert a Change list relative to this document. See crate::invert.

pub fn normalize(&mut self)

Normalize the document tree in place. See Node::normalize.

pub fn normalize_with(&mut self, opts: &NormalizeOptions)

Normalize with custom options. See Node::normalize_with.

pub fn to_html(&self) -> String

Render to an HTML string. See Node::to_html.

pub fn to_html_with(&self, opts: &HtmlOptions) -> String

Render to HTML with custom options. See Node::to_html_with.

Methods from Deref<Target = Node>

pub fn set_block_type( &mut self, path: &[usize], new_type: impl Into<String>, attrs: Option<Map<String, Value>>, ) -> Result<(), BlockError>

Change the type (and attrs) of the block at path in place, keeping its content — unlike a wholesale Change::Replace. attrs = None clears attrs. The root (&[]) may be retyped.

pub fn split_block( &mut self, path: &[usize], at: usize, depth: usize, ) -> Result<(), BlockError>

Split the block at path at child-boundary index at into two siblings: the left keeps children [..at], a new right sibling takes [at..] (same type/attrs/marks/extra). depth also splits that many ancestors (ProseMirror-style), clamped at the root.

pub fn split_block_at( &mut self, path: &[usize], pos: Position, depth: usize, ) -> Result<(), BlockError>

Split the block at path at an inline Position (materializing a mid-text boundary first), then split like Node::split_block.

pub fn join_blocks( &mut self, parent: &[usize], index: usize, ) -> Result<(), BlockError>

Merge the block at parent[index] into its previous sibling parent[index-1] (appending its content, re-merging inline text at the seam). The previous sibling’s type/attrs win on a mismatch.

pub fn wrap( &mut self, path: &[usize], wrapper_type: impl Into<String>, attrs: Option<Map<String, Value>>, ) -> Result<(), BlockError>

Wrap the single block at path in a new parent of wrapper_type.

pub fn wrap_range( &mut self, range: &BlockRange, wrapper_type: impl Into<String>, attrs: Option<Map<String, Value>>, ) -> Result<(), BlockError>

Wrap a contiguous run of sibling blocks (one level) in a new parent of wrapper_type. Nested structures (e.g. bulletList > listItem) are composed by the caller.

pub fn lift(&mut self, path: &[usize]) -> Result<(), BlockError>

Lift the block at path out of its parent into its grandparent, splitting the parent around it so preceding/following siblings are kept (a sole-child parent simply collapses to the lifted node).

pub fn diff(&self, other: &Node) -> Vec<Change>

Structural diff from self to other: a Change list that, when applied to a clone of self, reproduces other.

pub fn apply(&mut self, changes: &[Change]) -> Result<(), ApplyError>

Apply changes to self in order. See apply.

pub fn invert(&self, changes: &[Change]) -> Result<Vec<Change>, ApplyError>

Invert changes relative to self (the pre-image). See invert.

pub fn to_html(&self) -> String

Render this node (and its subtree) to an HTML string with default options.

pub fn to_html_with(&self, opts: &HtmlOptions) -> String

Render to HTML with custom HtmlOptions.

pub fn has_mark(&self, mark_type: &str) -> bool

True if a mark of mark_type is present.

pub fn get_mark(&self, mark_type: &str) -> Option<&Mark>

Reference to the first mark of mark_type.

pub fn add_mark(&mut self, mark: Mark) -> bool

Add mark if no mark of that type exists yet. Returns true if added.

pub fn remove_mark(&mut self, mark_type: &str) -> usize

Remove every mark of mark_type. Returns count removed.

pub fn toggle_mark(&mut self, mark: Mark) -> bool

Toggle a mark: remove if present, else add. Returns true if now present.

pub fn set_mark_attr( &mut self, mark_type: &str, key: impl Into<String>, value: impl Into<Value>, ) -> bool

Set an attr on the (first) mark of mark_type. Returns false if absent.

pub fn clear_marks(&mut self)

Drop all marks.

pub fn attr(&self, key: &str) -> Option<&Value>

Reference to attr key.

pub fn attrs_mut(&mut self) -> &mut Map<String, Value>

Mutable access to the attrs map, creating it if absent.

pub fn set_attr( &mut self, key: impl Into<String>, value: impl Into<Value>, ) -> Option<Value>

Set attr key, returning the previous value if any.

pub fn remove_attr(&mut self, key: &str) -> Option<Value>

Remove attr key, returning its value if present.

pub fn child_count(&self) -> usize

Number of direct children.

pub fn children(&self) -> &[Node]

Direct children slice (empty if none).

pub fn children_mut(&mut self) -> &mut Vec<Node>

Mutable access to children, creating the vec if absent.

pub fn child(&self, i: usize) -> Option<&Node>

Direct child at i.

pub fn child_mut(&mut self, i: usize) -> Option<&mut Node>

Mutable direct child at i.

pub fn push_child(&mut self, node: Node)

Append a child.

pub fn insert_child(&mut self, i: usize, node: Node)

Insert a child at i (clamped to len).

pub fn remove_child(&mut self, i: usize) -> Option<Node>

Remove and return the child at i.

pub fn replace_child(&mut self, i: usize, node: Node) -> Option<Node>

Replace the child at i, returning the old node.

pub fn clear_children(&mut self)

Remove all children.

pub fn retain_children(&mut self, pred: impl FnMut(&Node) -> bool)

Retain only children matching pred.

pub fn get_text(&self) -> Option<&str>

Text payload, if any.

pub fn set_text(&mut self, text: impl Into<String>)

Set text payload.

pub fn replace_all( &mut self, pred: impl FnMut(&Node) -> bool, f: impl FnMut(&mut Node), ) -> usize

Apply f to every node (incl. self) matching pred. Returns count.

pub fn normalize(&mut self)

Normalize this subtree in place with default NormalizeOptions.

pub fn normalize_with(&mut self, opts: &NormalizeOptions)

Normalize this subtree in place with custom NormalizeOptions.

pub fn node_at(&self, path: &[usize]) -> Option<&Node>

Node at path (relative to self), or None if any index is missing.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[{"type":"paragraph","content":[{"type":"text","text":"hi"}]}]}"#,
).unwrap();
assert_eq!(doc.node_at(&[0, 0]).unwrap().get_text(), Some("hi"));
assert!(doc.node_at(&[5]).is_none());

pub fn node_at_mut(&mut self, path: &[usize]) -> Option<&mut Node>

Mutable variant of Node::node_at.

pub fn path_to(&self, pred: impl FnMut(&Node) -> bool) -> Option<Vec<usize>>

Path to the first node (incl. self) matching pred, pre-order.

Returns Some(vec![]) when self matches.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[{"type":"paragraph","content":[{"type":"text","text":"hi"}]}]}"#,
).unwrap();
let p = doc.path_to(|n| n.node_type.as_deref() == Some("text")).unwrap();
assert_eq!(p, vec![0, 0]);
assert_eq!(doc.node_at(&p).unwrap().get_text(), Some("hi"));

pub fn paths_to(&self, pred: impl FnMut(&Node) -> bool) -> Vec<Vec<usize>>

Paths to every node (incl. self) matching pred, pre-order.

pub fn node_size(&self) -> usize

ProseMirror node size with the default LeafPolicy.

pub fn node_size_with(&self, policy: &LeafPolicy) -> usize

ProseMirror node size under policy.

pub fn content_size(&self) -> usize

Sum of child sizes (the count of inner positions) with the default policy.

pub fn content_size_with(&self, policy: &LeafPolicy) -> usize

Sum of child sizes under policy.

pub fn is_leaf(&self) -> bool

Whether this node is a ProseMirror leaf under the default policy.

pub fn is_leaf_with(&self, policy: &LeafPolicy) -> bool

Whether this node is a ProseMirror leaf under policy (non-text, and its type is in the leaf set).

pub fn resolve(&self, pos: usize) -> Result<ResolvedPos, PosError>

Resolve a flat position with the default LeafPolicy.

pub fn resolve_with( &self, pos: usize, policy: &LeafPolicy, ) -> Result<ResolvedPos, PosError>

Resolve a flat position into a ResolvedPos under policy.

pub fn pos_before(&self, path: &[usize]) -> Result<usize, PosError>

Flat position of the boundary just before the node at path (default policy).

pub fn pos_before_with( &self, path: &[usize], policy: &LeafPolicy, ) -> Result<usize, PosError>

Flat position of the boundary just before the node at path under policy.

pub fn pos_after(&self, path: &[usize]) -> Result<usize, PosError>

Flat position just after the node at path (default policy).

pub fn pos_after_with( &self, path: &[usize], policy: &LeafPolicy, ) -> Result<usize, PosError>

Flat position just after the node at path under policy.

pub fn pos_in_text( &self, text_path: &[usize], offset: usize, ) -> Result<usize, PosError>

Flat position at scalar offset inside the text node at text_path. Errors if text_path is not a text node or offset exceeds its length.

pub fn pos_to_inline( &self, pos: usize, ) -> Result<(Vec<usize>, Position), PosError>

Map a flat position to the (block path, inline Position) pair used by the inline range-editing API (Node::insert_text etc.), with the default policy. The block path is the resolved container.

pub fn inline_to_pos( &self, block_path: &[usize], inline: Position, ) -> Result<usize, PosError>

Inverse of Node::pos_to_inline: the flat position for a block-local inline Position (default policy).

pub fn walk(&self, f: &mut impl FnMut(&Node))

Visit self and every descendant, pre-order.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(r#"{"type":"doc","content":[{"type":"paragraph"}]}"#).unwrap();
let mut n = 0;
doc.root().walk(&mut |_| n += 1);
assert_eq!(n, 2);

pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Node))

Mutable pre-order visit of self and every descendant.

pub fn find(&self, pred: impl FnMut(&Node) -> bool) -> Option<&Node>

First node (incl. self) matching pred, pre-order.

pub fn find_mut(&mut self, pred: impl FnMut(&Node) -> bool) -> Option<&mut Node>

Mutable variant of Node::find.

pub fn find_all(&self, pred: impl FnMut(&Node) -> bool) -> Vec<&Node>

All nodes (incl. self) matching pred, pre-order.

pub fn find_all_mut( &mut self, pred: &mut impl FnMut(&Node) -> bool, ) -> Vec<&mut Node>

Mutable variant of Node::find_all. Collects matching &mut Node.

pub fn descendants(&self) -> Descendants<'_>

Lazy pre-order iterator over self and all descendants.

pub fn insert_text( &mut self, pos: Position, text: &str, marks: Option<&[Mark]>, ) -> Result<(), RangeError>

Insert text (with optional marks) at pos in this block’s inline content, splitting the target text node if needed and merging with adjacent equal-mark text afterwards.

pub fn delete_range(&mut self, range: Range) -> Result<(), RangeError>

Delete everything in range, splitting text nodes at the boundaries and removing fully-covered inline nodes. A collapsed range is a no-op.

pub fn replace_range( &mut self, range: Range, text: &str, marks: Option<&[Mark]>, ) -> Result<(), RangeError>

Replace range with text (carrying optional marks).

pub fn add_mark_range( &mut self, range: Range, mark: Mark, ) -> Result<(), RangeError>

Add mark to every text node covered by range (splitting at the boundaries first), then re-merge equal-mark neighbours.

pub fn remove_mark_range( &mut self, range: Range, mark_type: &str, ) -> Result<(), RangeError>

Remove every mark of mark_type from text nodes covered by range.

pub fn toggle_mark_range( &mut self, range: Range, mark: Mark, ) -> Result<(), RangeError>

Toggle mark over range: if every covered text node already has a mark of that type, remove it from all; otherwise add it to all. Mirrors the ProseMirror toggle semantics, range-scoped.

pub fn validate(&self, schema: &Schema) -> Vec<Violation>

Validate against schema, collecting every Violation. An empty result means the document is valid.

use tiptap_rusty_parser::{Document, Schema, NodeSpec};
let schema = Schema::new()
    .node("doc", NodeSpec::new().content(["paragraph"]))
    .node("paragraph", NodeSpec::new())
    .node("heading", NodeSpec::new());
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[{"type":"heading"}]}"#,
).unwrap();
let v = doc.validate(&schema);
assert_eq!(v.len(), 1); // heading is a known type, but not allowed as a child of doc

pub fn is_valid(&self, schema: &Schema) -> bool

True if the document has no schema violations.

use tiptap_rusty_parser::{Document, Schema, NodeSpec};
let schema = Schema::new().node("doc", NodeSpec::new());
let doc = Document::from_json_str(r#"{"type":"doc"}"#).unwrap();
assert!(doc.is_valid(&schema));

pub fn by_type(&self, node_type: &str) -> Vec<&Node>

All descendants (incl. self) whose type equals node_type.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[{"type":"paragraph"},{"type":"paragraph"}]}"#,
).unwrap();
assert_eq!(doc.by_type("paragraph").len(), 2);

pub fn first_by_type(&self, node_type: &str) -> Option<&Node>

First descendant (incl. self) whose type equals node_type, pre-order.

pub fn by_type_mut(&mut self, node_type: &str) -> Vec<&mut Node>

Mutable variant of Node::by_type.

pub fn by_mark(&self, mark_type: &str) -> Vec<&Node>

All descendants (incl. self) carrying a mark of mark_type.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[{"type":"text","text":"a","marks":[{"type":"bold"}]}]}"#,
).unwrap();
assert_eq!(doc.by_mark("bold").len(), 1);

pub fn by_attr(&self, key: &str, value: impl Into<Value>) -> Vec<&Node>

All descendants (incl. self) whose attribute key equals value.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[{"type":"heading","attrs":{"level":1}}]}"#,
).unwrap();
assert_eq!(doc.by_attr("level", 1).len(), 1);

pub fn text_content(&self) -> String

Concatenate all descendant text, with no separators.

Matches ProseMirror’s node.textContent.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[
        {"type":"paragraph","content":[{"type":"text","text":"Hello "},{"type":"text","text":"world"}]}
    ]}"#,
).unwrap();
assert_eq!(doc.text_content(), "Hello world");

pub fn text_content_with_separator(&self, sep: &str) -> String

Concatenate descendant text, inserting sep between adjacent block-level siblings (a node is “block-level” if it has content and is not a text node). Text within a block stays contiguous.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[
        {"type":"paragraph","content":[{"type":"text","text":"Hello"}]},
        {"type":"paragraph","content":[{"type":"text","text":"world"}]}
    ]}"#,
).unwrap();
assert_eq!(doc.text_content_with_separator("\n\n"), "Hello\n\nworld");

pub fn char_count(&self) -> usize

Total number of Unicode scalar values across all descendant text.

pub fn word_count(&self) -> usize

Number of words across all text, via Unicode word segmentation.

Blocks are separated by a space first, so words don’t merge across block boundaries. Correct for CJK and other complex scripts.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(
    r#"{"type":"doc","content":[
        {"type":"paragraph","content":[{"type":"text","text":"Hello"}]},
        {"type":"paragraph","content":[{"type":"text","text":"brave world"}]}
    ]}"#,
).unwrap();
assert_eq!(doc.word_count(), 3);

pub fn transform(&mut self) -> Transform<'_>

Begin a Transform over this tree.

Trait Implementations

impl Clone for Document

fn clone(&self) -> Document

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Document

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for Document

type Target = Node

The resulting type after dereferencing.

fn deref(&self) -> &Node

Dereferences the value.

impl DerefMut for Document

fn deref_mut(&mut self) -> &mut Node

Mutably dereferences the value.

impl From<Node> for Document

fn from(root: Node) -> Self

Converts to this type from the input type.

impl PartialEq for Document

fn eq(&self, other: &Document) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Document