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.

Methods from Deref<Target = Node>

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 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.

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