use std::{
borrow::Cow,
ops::Range,
sync::{Arc, OnceLock},
};
use unicode_segmentation::UnicodeSegmentation;
use crate::{Error, Fragment, InlineStyle, ParagraphKind, Position, StylePatch};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Span {
pub range: Range<usize>,
pub style: InlineStyle,
}
#[derive(Clone, Debug)]
pub struct Paragraph {
text: Arc<str>,
spans: Arc<[Span]>,
kind: ParagraphKind,
ascii: bool,
indices: Option<Arc<TextIndices>>,
}
#[derive(Debug, Default)]
struct TextIndices {
graphemes: OnceLock<Box<[usize]>>,
scalars: OnceLock<Box<[usize]>>,
words: OnceLock<Box<[Range<usize>]>>,
}
impl PartialEq for Paragraph {
fn eq(&self, other: &Self) -> bool {
self.text == other.text && self.spans == other.spans && self.kind == other.kind
}
}
impl Eq for Paragraph {}
impl Paragraph {
pub fn text(&self) -> &str {
&self.text
}
pub fn spans(&self) -> &[Span] {
&self.spans
}
pub fn kind(&self) -> ParagraphKind {
self.kind
}
pub fn grapheme_count(&self) -> usize {
if self.ascii {
self.text.len()
} else {
self.grapheme_boundaries().len() - 1
}
}
pub fn byte_from_grapheme(&self, index: usize) -> Option<usize> {
if self.ascii {
(index <= self.text.len()).then_some(index)
} else {
self.grapheme_boundaries().get(index).copied()
}
}
pub fn grapheme_index(&self, byte: usize) -> Option<usize> {
if byte == 0 {
Some(0)
} else if byte > self.text.len() || !self.text.is_char_boundary(byte) {
None
} else if self.ascii {
(byte <= self.text.len()).then_some(byte)
} else {
self.grapheme_boundaries().binary_search(&byte).ok()
}
}
pub fn previous_grapheme(&self, byte: usize) -> usize {
if byte == 0 {
0
} else if self.ascii {
byte.saturating_sub(1).min(self.text.len())
} else {
let boundaries = self.grapheme_boundaries();
boundaries[boundaries
.partition_point(|offset| *offset < byte)
.saturating_sub(1)]
}
}
pub fn next_grapheme(&self, byte: usize) -> usize {
if byte >= self.text.len() {
self.text.len()
} else if self.ascii {
byte.saturating_add(1).min(self.text.len())
} else {
let boundaries = self.grapheme_boundaries();
boundaries[boundaries
.partition_point(|offset| *offset <= byte)
.min(boundaries.len() - 1)]
}
}
pub fn boundary_at_or_before(&self, byte: usize) -> usize {
if byte == 0 || byte >= self.text.len() || self.ascii {
byte.min(self.text.len())
} else {
let boundaries = self.grapheme_boundaries();
boundaries[boundaries
.partition_point(|offset| *offset <= byte)
.saturating_sub(1)]
}
}
pub fn boundary_at_or_after(&self, byte: usize) -> usize {
if byte == 0 || byte >= self.text.len() || self.ascii {
byte.min(self.text.len())
} else {
let boundaries = self.grapheme_boundaries();
boundaries[boundaries
.partition_point(|offset| *offset < byte)
.min(boundaries.len() - 1)]
}
}
pub fn scalar_count(&self) -> usize {
if self.ascii {
self.text.len()
} else {
self.scalar_boundaries().len() - 1
}
}
pub fn byte_from_scalar(&self, index: usize) -> Option<usize> {
if self.ascii {
(index <= self.text.len()).then_some(index)
} else {
self.scalar_boundaries().get(index).copied()
}
}
pub fn scalar_index(&self, byte: usize) -> Option<usize> {
if byte == 0 {
Some(0)
} else if byte > self.text.len() || !self.text.is_char_boundary(byte) {
None
} else if self.ascii {
(byte <= self.text.len()).then_some(byte)
} else {
self.scalar_boundaries().binary_search(&byte).ok()
}
}
pub fn previous_word(&self, byte: usize) -> usize {
if byte == 0 {
return 0;
}
let byte = if self.ascii {
self.text
.unicode_word_indices()
.rev()
.find(|(start, _)| *start < byte)
.map_or(0, |(start, _)| start)
} else {
let words = self.word_ranges();
words
.get(
words
.partition_point(|word| word.start < byte)
.wrapping_sub(1),
)
.map_or(0, |word| word.start)
};
self.boundary_at_or_before(byte)
}
pub fn next_word(&self, byte: usize) -> usize {
if byte >= self.text.len() {
return self.text.len();
}
let byte = if self.ascii {
self.text
.unicode_word_indices()
.find(|(start, word)| start + word.len() > byte)
.map_or(self.text.len(), |(start, word)| start + word.len())
} else {
let words = self.word_ranges();
words
.get(words.partition_point(|word| word.end <= byte))
.map_or(self.text.len(), |word| word.end)
};
self.boundary_at_or_after(byte)
}
fn grapheme_boundaries(&self) -> &[usize] {
self.indices
.as_ref()
.expect("non-ASCII paragraph has an index cache")
.graphemes
.get_or_init(|| {
self.text
.grapheme_indices(true)
.map(|(byte, _)| byte)
.chain([self.text.len()])
.collect()
})
}
fn scalar_boundaries(&self) -> &[usize] {
self.indices
.as_ref()
.expect("non-ASCII paragraph has an index cache")
.scalars
.get_or_init(|| {
self.text
.char_indices()
.map(|(byte, _)| byte)
.chain([self.text.len()])
.collect()
})
}
fn word_ranges(&self) -> &[Range<usize>] {
self.indices
.as_ref()
.expect("non-ASCII paragraph has an index cache")
.words
.get_or_init(|| {
self.text
.unicode_word_indices()
.map(|(byte, word)| byte..byte + word.len())
.collect()
})
}
fn with_kind(&self, kind: ParagraphKind) -> Self {
Self {
text: Arc::clone(&self.text),
spans: Arc::clone(&self.spans),
kind,
ascii: self.ascii,
indices: self.indices.clone(),
}
}
fn plain(text: &str) -> Self {
let spans = if text.is_empty() {
Vec::new()
} else {
vec![Span {
range: 0..text.len(),
style: InlineStyle::default(),
}]
};
Self {
text: Arc::from(text),
spans: spans.into(),
kind: ParagraphKind::Body,
ascii: text.is_ascii(),
indices: (!text.is_ascii()).then(|| Arc::new(TextIndices::default())),
}
}
fn styled(text: String, raw_spans: Vec<Span>, kind: ParagraphKind) -> Self {
let ascii = text.is_ascii();
let spans = normalize_spans(&text, &raw_spans, ascii);
Self {
text: text.into(),
spans: spans.into(),
kind,
ascii,
indices: (!ascii).then(|| Arc::new(TextIndices::default())),
}
}
pub(crate) fn from_parts(
text: String,
spans: Vec<Span>,
kind: ParagraphKind,
) -> Result<Self, Error> {
if text.contains(['\r', '\n'])
|| matches!(kind, ParagraphKind::Heading { level } if !(1..=6).contains(&level))
{
return Err(Error::InvalidFragment);
}
let ascii = text.is_ascii();
let mut paragraph = Self {
text: text.into(),
spans: Arc::from([]),
kind,
ascii,
indices: (!ascii).then(|| Arc::new(TextIndices::default())),
};
let mut normalized = Vec::with_capacity(spans.len());
let mut end = 0;
for span in spans {
if span.range.start != end
|| span.range.start >= span.range.end
|| span.range.end > paragraph.text.len()
|| (span.range.end < paragraph.text.len()
&& paragraph.grapheme_index(span.range.end).is_none())
{
return Err(Error::InvalidFragment);
}
end = span.range.end;
push_span(&mut normalized, span.range, span.style);
}
if end != paragraph.text.len() {
return Err(Error::InvalidFragment);
}
paragraph.spans = normalized.into();
Ok(paragraph)
}
fn style_for_byte(&self, byte: usize) -> InlineStyle {
let index = self.spans.partition_point(|span| span.range.end <= byte);
self.spans
.get(index)
.map_or_else(InlineStyle::default, |span| span.style)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Document {
paragraphs: Vec<Arc<Paragraph>>,
revision: u64,
identity: Arc<()>,
}
impl Default for Document {
fn default() -> Self {
Self::from_text("")
}
}
impl Document {
pub fn new() -> Self {
Self::default()
}
pub fn from_text(text: &str) -> Self {
let text = normalize_newlines(text);
Self {
paragraphs: text
.split('\n')
.map(|text| Arc::new(Paragraph::plain(text)))
.collect(),
revision: 0,
identity: Arc::new(()),
}
}
pub fn from_fragment(fragment: &Fragment) -> Self {
Self {
paragraphs: fragment.paragraphs().to_vec(),
revision: 0,
identity: Arc::new(()),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
Fragment::encode_paragraphs(self.paragraphs())
}
pub fn from_bytes(bytes: &[u8]) -> Result<Self, crate::FragmentError> {
Fragment::from_bytes(bytes).map(|fragment| Self::from_fragment(&fragment))
}
pub fn to_html(&self) -> String {
crate::export::html(self.paragraphs())
}
pub fn fragment(&self, range: Range<Position>) -> Result<Fragment, Error> {
self.validate_range(&range)?;
let mut paragraphs = Vec::with_capacity(range.end.paragraph - range.start.paragraph + 1);
for index in range.start.paragraph..=range.end.paragraph {
let paragraph = &self.paragraphs[index];
let start = if index == range.start.paragraph {
range.start.byte
} else {
0
};
let end = if index == range.end.paragraph {
range.end.byte
} else {
paragraph.text.len()
};
if start == 0 && end == paragraph.text.len() {
paragraphs.push(Arc::clone(paragraph));
} else {
let mut text = String::with_capacity(end - start);
let mut spans = Vec::new();
append_slice(&mut text, &mut spans, paragraph, start..end);
paragraphs.push(Arc::new(Paragraph::styled(text, spans, paragraph.kind)));
}
}
Ok(Fragment::from_paragraphs(paragraphs))
}
pub fn paragraphs(&self) -> &[Arc<Paragraph>] {
&self.paragraphs
}
pub fn paragraph(&self, index: usize) -> Option<&Paragraph> {
self.paragraphs.get(index).map(Arc::as_ref)
}
pub fn end(&self) -> Position {
let paragraph = self.paragraphs.len() - 1;
Position::new(paragraph, self.paragraphs[paragraph].text.len())
}
pub fn revision(&self) -> u64 {
self.revision
}
#[cfg(feature = "egui")]
pub(crate) fn content_identity(&self) -> Arc<()> {
Arc::clone(&self.identity)
}
pub fn plain_text(&self) -> String {
let capacity = self
.paragraphs
.iter()
.map(|paragraph| paragraph.text.len())
.sum::<usize>()
.saturating_add(self.paragraphs.len() - 1);
let mut result = String::with_capacity(capacity);
for (index, paragraph) in self.paragraphs.iter().enumerate() {
if index != 0 {
result.push('\n');
}
result.push_str(paragraph.text());
}
result
}
pub fn text(&self, range: Range<Position>) -> Result<String, Error> {
self.validate_range(&range)?;
let mut result = String::new();
for index in range.start.paragraph..=range.end.paragraph {
if index != range.start.paragraph {
result.push('\n');
}
let paragraph = &self.paragraphs[index];
let start = if index == range.start.paragraph {
range.start.byte
} else {
0
};
let end = if index == range.end.paragraph {
range.end.byte
} else {
paragraph.text.len()
};
result.push_str(¶graph.text[start..end]);
}
Ok(result)
}
pub fn validate_position(&self, position: Position) -> Result<(), Error> {
let Some(paragraph) = self.paragraph(position.paragraph) else {
return Err(Error::InvalidPosition(position));
};
if position.byte == 0
|| position.byte == paragraph.text.len()
|| paragraph.grapheme_index(position.byte).is_some()
{
Ok(())
} else {
Err(Error::InvalidPosition(position))
}
}
pub fn style_at(&self, position: Position) -> InlineStyle {
let Some(paragraph) = self.paragraph(position.paragraph) else {
return InlineStyle::default();
};
if position.byte > paragraph.text.len() {
return InlineStyle::default();
}
paragraph.style_for_byte(position.byte.saturating_sub(1))
}
fn validate_range(&self, range: &Range<Position>) -> Result<(), Error> {
if range.start > range.end {
return Err(Error::InvalidRange);
}
self.validate_position(range.start)?;
self.validate_position(range.end)
}
pub(crate) fn replace(
&mut self,
range: Range<Position>,
text: &str,
style: InlineStyle,
) -> Result<(Delta, Position), Error> {
self.validate_range(&range)?;
let text = normalize_newlines(text);
let first = &self.paragraphs[range.start.paragraph];
let last = &self.paragraphs[range.end.paragraph];
let chunks: Vec<&str> = text.split('\n').collect();
let mut after = Vec::with_capacity(chunks.len());
let mut insertion_end = 0;
for (index, chunk) in chunks.iter().enumerate() {
let is_first = index == 0;
let is_last = index + 1 == chunks.len();
let capacity = chunk
.len()
.saturating_add(if is_first { range.start.byte } else { 0 })
.saturating_add(if is_last {
last.text.len() - range.end.byte
} else {
0
});
let mut output = String::with_capacity(capacity);
let mut spans = Vec::new();
if is_first {
append_slice(&mut output, &mut spans, first, 0..range.start.byte);
}
let start = output.len();
output.push_str(chunk);
push_span(&mut spans, start..output.len(), style);
if is_last {
insertion_end = output.len();
append_slice(
&mut output,
&mut spans,
last,
range.end.byte..last.text.len(),
);
}
let mut kind = if is_first {
if is_last
&& range.start.paragraph != range.end.paragraph
&& range.start.byte == 0
&& text.is_empty()
{
last.kind
} else {
first.kind
}
} else if is_last && range.start.paragraph != range.end.paragraph {
last.kind
} else {
continuation_kind(first.kind, index)
};
if is_first
&& let (
ParagraphKind::Ordered {
indent: first_indent,
start,
},
ParagraphKind::Ordered { indent, .. },
) = (first.kind, kind)
&& first_indent == indent
{
kind = ParagraphKind::Ordered { indent, start };
}
after.push(Arc::new(Paragraph::styled(output, spans, kind)));
}
let caret_paragraph = range.start.paragraph + after.len() - 1;
let caret_source = after.last().expect("replacement has a paragraph");
let caret = Position::new(
caret_paragraph,
boundary_at_or_after(caret_source, insertion_end),
);
let paragraph_range = range.start.paragraph..range.end.paragraph + 1;
let (paragraph_range, after) =
if range.start.paragraph != range.end.paragraph || chunks.len() > 1 {
self.with_numbered_continuations(paragraph_range, after)
} else {
(paragraph_range, after)
};
let delta = self.change(paragraph_range, after);
Ok((delta, caret))
}
pub(crate) fn replace_fragment(
&mut self,
range: Range<Position>,
fragment: &Fragment,
) -> Result<(Delta, Position), Error> {
self.validate_range(&range)?;
let first = &self.paragraphs[range.start.paragraph];
let last = &self.paragraphs[range.end.paragraph];
let mut after = Vec::with_capacity(fragment.paragraphs().len());
let mut insertion_end = 0;
for (index, source) in fragment.paragraphs().iter().enumerate() {
let is_first = index == 0;
let is_last = index + 1 == fragment.paragraphs().len();
let prefix_len = if is_first { range.start.byte } else { 0 };
let suffix_len = if is_last {
last.text.len() - range.end.byte
} else {
0
};
let kind = if is_first && prefix_len > 0 {
first.kind
} else {
source.kind
};
if prefix_len == 0 && suffix_len == 0 && kind == source.kind {
if is_last {
insertion_end = source.text.len();
}
after.push(Arc::clone(source));
continue;
}
let mut text = String::with_capacity(prefix_len + source.text.len() + suffix_len);
let mut spans = Vec::new();
if is_first {
append_slice(&mut text, &mut spans, first, 0..range.start.byte);
}
append_slice(&mut text, &mut spans, source, 0..source.text.len());
if is_last {
insertion_end = text.len();
append_slice(&mut text, &mut spans, last, range.end.byte..last.text.len());
}
after.push(Arc::new(Paragraph::styled(text, spans, kind)));
}
let caret = Position::new(
range.start.paragraph + after.len() - 1,
after
.last()
.expect("fragment has a paragraph")
.boundary_at_or_after(insertion_end),
);
let delta = self.change(range.start.paragraph..range.end.paragraph + 1, after);
Ok((delta, caret))
}
pub(crate) fn change_list_indent(&mut self, range: Range<usize>, increase: bool) -> Delta {
let after = self.paragraphs[range.clone()]
.iter()
.map(|paragraph| {
let kind = match paragraph.kind {
ParagraphKind::Bullet { indent } => {
if increase {
ParagraphKind::Bullet {
indent: indent.saturating_add(1),
}
} else if indent == 0 {
ParagraphKind::Body
} else {
ParagraphKind::Bullet { indent: indent - 1 }
}
}
ParagraphKind::Ordered { indent, start } => {
if increase {
ParagraphKind::Ordered {
indent: indent.saturating_add(1),
start,
}
} else if indent == 0 {
ParagraphKind::Body
} else {
ParagraphKind::Ordered {
indent: indent - 1,
start,
}
}
}
kind => kind,
};
if kind == paragraph.kind {
Arc::clone(paragraph)
} else {
Arc::new(paragraph.with_kind(kind))
}
})
.collect();
self.change(range, after)
}
pub(crate) fn replace_matches(
&mut self,
matches: &[Range<Position>],
replacement: &str,
) -> Result<(Delta, Position), Error> {
let first = matches.first().expect("nonempty matches");
let last = matches.last().expect("nonempty matches");
let mut cursor = Position::new(first.start.paragraph, 0);
for range in matches {
self.validate_range(range)?;
if range.start < cursor || range.is_empty() {
return Err(Error::InvalidRange);
}
cursor = range.end;
}
let replacement = normalize_newlines(replacement);
let mut builder = ReplacementBuilder::new(self.paragraphs[first.start.paragraph].kind);
cursor = Position::new(first.start.paragraph, 0);
let mut caret = Position::default();
for range in matches {
builder.append_document(self, cursor..range.start);
let source = &self.paragraphs[range.start.paragraph];
let style =
source.style_for_byte(range.start.byte.min(source.text.len().saturating_sub(1)));
if range.start.paragraph != range.end.paragraph
&& range.start.byte == 0
&& replacement.is_empty()
&& builder.text.is_empty()
{
builder.kind = self.paragraphs[range.end.paragraph].kind;
if let (
ParagraphKind::Ordered {
indent: first_indent,
start,
},
ParagraphKind::Ordered { indent, .. },
) = (source.kind, builder.kind)
&& first_indent == indent
{
builder.kind = ParagraphKind::Ordered { indent, start };
}
}
builder.append_text(&replacement, style);
if range.start.paragraph != range.end.paragraph && replacement.contains('\n') {
builder.kind = self.paragraphs[range.end.paragraph].kind;
}
caret = Position::new(
first.start.paragraph + builder.paragraphs.len(),
builder.text.len(),
);
cursor = range.end;
}
builder.append_document(
self,
cursor
..Position::new(
last.end.paragraph,
self.paragraphs[last.end.paragraph].text.len(),
),
);
builder.finish_paragraph();
let mut after = builder.paragraphs;
caret.byte =
after[caret.paragraph - first.start.paragraph].boundary_at_or_after(caret.byte);
let range = first.start.paragraph..last.end.paragraph + 1;
let structural = replacement.contains('\n')
|| matches
.iter()
.any(|range| range.start.paragraph != range.end.paragraph);
let range = if structural {
let (range, numbered) = self.with_numbered_continuations(range, after);
after = numbered;
range
} else {
range
};
Ok((self.change(range, after), caret))
}
pub(crate) fn apply_style(
&mut self,
range: Range<Position>,
patch: StylePatch,
) -> Result<Option<Delta>, Error> {
self.validate_range(&range)?;
if range.is_empty() {
return Ok(None);
}
let mut after = Vec::with_capacity(range.end.paragraph - range.start.paragraph + 1);
for index in range.start.paragraph..=range.end.paragraph {
let paragraph = &self.paragraphs[index];
let start = if index == range.start.paragraph {
range.start.byte
} else {
0
};
let end = if index == range.end.paragraph {
range.end.byte
} else {
paragraph.text.len()
};
let mut spans = Vec::new();
for span in paragraph.spans.iter() {
let overlap = span.range.start.max(start)..span.range.end.min(end);
if overlap.start >= overlap.end {
push_span(&mut spans, span.range.clone(), span.style);
continue;
}
push_span(&mut spans, span.range.start..overlap.start, span.style);
let mut style = span.style;
patch.apply(&mut style);
push_span(&mut spans, overlap.clone(), style);
push_span(&mut spans, overlap.end..span.range.end, span.style);
}
if spans.as_slice() == paragraph.spans() {
after.push(Arc::clone(paragraph));
} else {
after.push(Arc::new(Paragraph {
text: Arc::clone(¶graph.text),
spans: spans.into(),
kind: paragraph.kind,
ascii: paragraph.ascii,
indices: paragraph.indices.clone(),
}));
}
}
let delta = self.change(range.start.paragraph..range.end.paragraph + 1, after);
Ok((!delta.is_empty()).then_some(delta))
}
pub(crate) fn set_kind(
&mut self,
range: Range<usize>,
kind: ParagraphKind,
) -> Result<Option<Delta>, Error> {
if range.start > range.end || range.end > self.paragraphs.len() {
return Err(Error::InvalidRange);
}
if let ParagraphKind::Heading { level } = kind
&& !(1..=6).contains(&level)
{
return Err(Error::InvalidHeadingLevel(level));
}
let after = self.paragraphs[range.clone()]
.iter()
.enumerate()
.map(|(offset, paragraph)| {
let kind = numbered_kind(kind, offset);
if paragraph.kind == kind {
Arc::clone(paragraph)
} else {
Arc::new(paragraph.with_kind(kind))
}
})
.collect();
let (range, after) = self.with_numbered_continuations(range, after);
let delta = self.change(range, after);
Ok((!delta.is_empty()).then_some(delta))
}
pub(crate) fn replay(&mut self, delta: &Delta, forward: bool) {
if delta.is_empty() {
return;
}
let (remove, insert) = if forward {
(&delta.before, &delta.after)
} else {
(&delta.after, &delta.before)
};
debug_assert_eq!(
self.paragraphs.get(delta.start..delta.start + remove.len()),
Some(remove.as_slice()),
"history must be replayed against its corresponding document state"
);
self.paragraphs.splice(
delta.start..delta.start + remove.len(),
insert.iter().cloned(),
);
self.revision = self.revision.saturating_add(1);
self.identity = Arc::new(());
}
fn with_numbered_continuations(
&self,
mut range: Range<usize>,
mut after: Vec<Arc<Paragraph>>,
) -> (Range<usize>, Vec<Arc<Paragraph>>) {
for index in 1..after.len() {
if let Some(kind) = next_numbered_kind(after[index - 1].kind, after[index].kind)
&& after[index].kind != kind
{
after[index] = Arc::new(after[index].with_kind(kind));
}
}
let Some(last) = after.last() else {
return (range, after);
};
let mut previous = last.kind;
for paragraph in &self.paragraphs[range.end..] {
let Some(kind) = next_numbered_kind(previous, paragraph.kind) else {
break;
};
after.push(if paragraph.kind == kind {
Arc::clone(paragraph)
} else {
Arc::new(paragraph.with_kind(kind))
});
range.end += 1;
previous = kind;
}
(range, after)
}
fn change(&mut self, range: Range<usize>, mut after: Vec<Arc<Paragraph>>) -> Delta {
let mut start = range.start;
let mut end = range.end;
let mut prefix = 0;
while start < end
&& prefix < after.len()
&& self.paragraphs[start].as_ref() == after[prefix].as_ref()
{
start += 1;
prefix += 1;
}
after.drain(..prefix);
while start < end
&& after
.last()
.is_some_and(|paragraph| self.paragraphs[end - 1].as_ref() == paragraph.as_ref())
{
end -= 1;
after.pop();
}
let before = self.paragraphs[start..end].to_vec();
let delta = Delta {
start,
before,
after,
};
if !delta.is_empty() {
self.paragraphs
.splice(start..end, delta.after.iter().cloned());
self.revision = self.revision.saturating_add(1);
self.identity = Arc::new(());
}
delta
}
}
struct ReplacementBuilder {
paragraphs: Vec<Arc<Paragraph>>,
text: String,
spans: Vec<Span>,
kind: ParagraphKind,
candidate: Option<Arc<Paragraph>>,
}
impl ReplacementBuilder {
fn new(kind: ParagraphKind) -> Self {
Self {
paragraphs: Vec::new(),
text: String::new(),
spans: Vec::new(),
kind,
candidate: None,
}
}
fn finish_paragraph(&mut self) {
let text = std::mem::take(&mut self.text);
let spans = std::mem::take(&mut self.spans);
if let Some(paragraph) = self.candidate.take()
&& paragraph.kind == self.kind
&& paragraph.text.as_ref() == text
&& paragraph.spans.as_ref() == spans
{
self.paragraphs.push(paragraph);
} else {
self.paragraphs
.push(Arc::new(Paragraph::styled(text, spans, self.kind)));
}
}
fn append_document(&mut self, document: &Document, range: Range<Position>) {
for index in range.start.paragraph..=range.end.paragraph {
let paragraph = &document.paragraphs[index];
if index > range.start.paragraph {
self.finish_paragraph();
self.kind = paragraph.kind;
}
let start = if index == range.start.paragraph {
range.start.byte
} else {
0
};
let end = if index == range.end.paragraph {
range.end.byte
} else {
paragraph.text.len()
};
if self.text.is_empty() && start == 0 && end == paragraph.text.len() {
self.candidate = Some(Arc::clone(paragraph));
} else if start < end {
self.candidate = None;
}
append_slice(&mut self.text, &mut self.spans, paragraph, start..end);
}
}
fn append_text(&mut self, text: &str, style: InlineStyle) {
for (index, chunk) in text.split('\n').enumerate() {
if index > 0 {
self.finish_paragraph();
self.kind = continuation_kind(self.kind, 1);
}
let start = self.text.len();
if !chunk.is_empty() {
self.candidate = None;
}
self.text.push_str(chunk);
push_span(&mut self.spans, start..self.text.len(), style);
}
}
}
#[derive(Clone, Debug)]
pub(crate) struct Delta {
pub start: usize,
pub before: Vec<Arc<Paragraph>>,
pub after: Vec<Arc<Paragraph>>,
}
impl Delta {
pub fn is_empty(&self) -> bool {
self.before.is_empty() && self.after.is_empty()
}
pub fn retained_bytes(&self) -> usize {
self.before
.iter()
.chain(&self.after)
.map(|paragraph| {
std::mem::size_of::<Paragraph>()
.saturating_add(paragraph.text.len())
.saturating_add(std::mem::size_of_val(paragraph.spans()))
})
.fold(0, usize::saturating_add)
}
}
fn normalize_newlines(text: &str) -> Cow<'_, str> {
if !text.contains('\r') {
return Cow::Borrowed(text);
}
Cow::Owned(text.replace("\r\n", "\n").replace('\r', "\n"))
}
fn continuation_kind(kind: ParagraphKind, offset: usize) -> ParagraphKind {
match kind {
ParagraphKind::Heading { .. } => ParagraphKind::Body,
other => numbered_kind(other, offset),
}
}
fn numbered_kind(kind: ParagraphKind, offset: usize) -> ParagraphKind {
match kind {
ParagraphKind::Ordered { indent, start } => ParagraphKind::Ordered {
indent,
start: start.saturating_add(u32::try_from(offset).unwrap_or(u32::MAX)),
},
other => other,
}
}
fn next_numbered_kind(previous: ParagraphKind, current: ParagraphKind) -> Option<ParagraphKind> {
if let (
ParagraphKind::Ordered {
indent: previous_indent,
start,
},
ParagraphKind::Ordered { indent, .. },
) = (previous, current)
&& previous_indent == indent
{
Some(ParagraphKind::Ordered {
indent,
start: start.saturating_add(1),
})
} else {
None
}
}
fn append_slice(
text: &mut String,
spans: &mut Vec<Span>,
paragraph: &Paragraph,
range: Range<usize>,
) {
let offset = text.len();
text.push_str(¶graph.text[range.clone()]);
let first = paragraph
.spans
.partition_point(|span| span.range.end <= range.start);
for span in ¶graph.spans[first..] {
if span.range.start >= range.end {
break;
}
let start = span.range.start.max(range.start) - range.start + offset;
let end = span.range.end.min(range.end) - range.start + offset;
push_span(spans, start..end, span.style);
}
}
fn push_span(spans: &mut Vec<Span>, range: Range<usize>, style: InlineStyle) {
if range.is_empty() {
return;
}
if let Some(last) = spans.last_mut()
&& last.range.end == range.start
&& last.style == style
{
last.range.end = range.end;
return;
}
spans.push(Span { range, style });
}
fn normalize_spans(text: &str, raw: &[Span], ascii: bool) -> Vec<Span> {
if ascii || raw.len() <= 1 {
return raw.to_vec();
}
let mut result = Vec::with_capacity(raw.len());
let mut index = 0;
for (start, grapheme) in text.grapheme_indices(true) {
while raw.get(index).is_some_and(|span| span.range.end <= start) {
index += 1;
}
let style = raw
.get(index)
.map_or_else(InlineStyle::default, |span| span.style);
push_span(&mut result, start..start + grapheme.len(), style);
}
result
}
fn boundary_at_or_after(paragraph: &Paragraph, byte: usize) -> usize {
paragraph.boundary_at_or_after(byte)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn indexed_unicode_offsets_match_extended_graphemes_and_scalars() {
for text in [
"",
"plain ASCII",
"café e\u{301}",
"👨👩👧👦🇺🇸🇨🇦🇯🇵",
"क्ष नमस्ते",
"a\u{301}\u{302}👩🏽💻z",
] {
let paragraph = Paragraph::plain(text);
let graphemes: Vec<_> = text
.grapheme_indices(true)
.map(|(byte, _)| byte)
.chain([text.len()])
.collect();
let scalars: Vec<_> = text
.char_indices()
.map(|(byte, _)| byte)
.chain([text.len()])
.collect();
assert_eq!(paragraph.grapheme_count(), graphemes.len() - 1);
assert_eq!(paragraph.scalar_count(), scalars.len() - 1);
for (index, byte) in graphemes.iter().enumerate() {
assert_eq!(paragraph.byte_from_grapheme(index), Some(*byte));
assert_eq!(paragraph.grapheme_index(*byte), Some(index));
}
for (index, byte) in scalars.iter().enumerate() {
assert_eq!(paragraph.byte_from_scalar(index), Some(*byte));
assert_eq!(paragraph.scalar_index(*byte), Some(index));
}
assert_eq!(paragraph.byte_from_grapheme(graphemes.len()), None);
assert_eq!(paragraph.byte_from_scalar(scalars.len()), None);
for byte in 0..=text.len() + 2 {
assert_eq!(
paragraph.grapheme_index(byte),
graphemes.iter().position(|offset| *offset == byte)
);
assert_eq!(
paragraph.scalar_index(byte),
scalars.iter().position(|offset| *offset == byte)
);
assert_eq!(
paragraph.previous_grapheme(byte),
graphemes
.iter()
.copied()
.rev()
.find(|offset| *offset < byte)
.unwrap_or(0)
);
assert_eq!(
paragraph.next_grapheme(byte),
graphemes
.iter()
.copied()
.find(|offset| *offset > byte)
.unwrap_or(text.len())
);
assert_eq!(
paragraph.boundary_at_or_before(byte),
graphemes
.iter()
.copied()
.rev()
.find(|offset| *offset <= byte)
.unwrap_or(0)
);
assert_eq!(
paragraph.boundary_at_or_after(byte),
graphemes
.iter()
.copied()
.find(|offset| *offset >= byte)
.unwrap_or(text.len())
);
}
}
}
#[test]
fn word_navigation_matches_unicode_segmentation() {
for text in [
"",
"one, two's!",
"café 👩💻 नमस्ते 🇺🇸",
"你好世界 e\u{301}",
"!!!",
] {
let paragraph = Paragraph::plain(text);
for byte in 0..=text.len() + 1 {
let previous = text
.unicode_word_indices()
.rev()
.find(|(start, _)| *start < byte)
.map_or(0, |(start, _)| start);
let next = text
.unicode_word_indices()
.find(|(start, word)| start + word.len() > byte)
.map_or(text.len(), |(start, word)| start + word.len());
assert_eq!(
paragraph.previous_word(byte),
paragraph.boundary_at_or_before(previous)
);
assert_eq!(
paragraph.next_word(byte),
paragraph.boundary_at_or_after(next)
);
}
}
}
#[test]
fn unicode_indexes_are_independently_lazy_and_shared_across_metadata_changes() {
let mut document = Document::from_text("café 👩💻");
let original = Arc::clone(&document.paragraphs()[0]);
let indices = original.indices.as_ref().unwrap();
assert!(indices.graphemes.get().is_none());
assert!(indices.scalars.get().is_none());
assert!(indices.words.get().is_none());
let equal = Paragraph::plain(original.text());
assert_eq!(*original, equal);
original.grapheme_count();
assert_eq!(*original, equal);
assert!(indices.graphemes.get().is_some());
assert!(indices.scalars.get().is_none());
assert!(indices.words.get().is_none());
document
.set_kind(0..1, ParagraphKind::Heading { level: 2 })
.unwrap();
assert!(Arc::ptr_eq(
indices,
document.paragraph(0).unwrap().indices.as_ref().unwrap()
));
document
.apply_style(
Position::default()..document.end(),
StylePatch {
bold: Some(true),
..StylePatch::default()
},
)
.unwrap();
assert!(Arc::ptr_eq(
indices,
document.paragraph(0).unwrap().indices.as_ref().unwrap()
));
document
.replace(document.end()..document.end(), "!", InlineStyle::default())
.unwrap();
assert!(!Arc::ptr_eq(
indices,
document.paragraph(0).unwrap().indices.as_ref().unwrap()
));
assert!(Paragraph::plain("ASCII").indices.is_none());
}
#[test]
fn uniform_unicode_end_typing_does_not_build_text_indexes() {
let mut document = Document::from_text("café 👩💻");
for _ in 0..3 {
document
.replace(document.end()..document.end(), "é", InlineStyle::default())
.unwrap();
let paragraph = document.paragraph(0).unwrap();
assert_eq!(paragraph.spans().len(), 1);
let indices = paragraph.indices.as_ref().unwrap();
assert!(indices.graphemes.get().is_none());
assert!(indices.scalars.get().is_none());
assert!(indices.words.get().is_none());
}
assert_normalized(&document);
}
#[test]
fn rich_parts_validate_and_merge_runs() {
let paragraph = Paragraph::from_parts(
"aé".into(),
vec![
Span {
range: 0..1,
style: bold(),
},
Span {
range: 1..3,
style: bold(),
},
],
ParagraphKind::Heading { level: 1 },
)
.unwrap();
assert_eq!(
paragraph.spans(),
&[Span {
range: 0..3,
style: bold()
}]
);
assert!(Paragraph::from_parts(String::new(), vec![], ParagraphKind::Body).is_ok());
for (text, spans, kind) in [
(
"a\nb",
vec![Span {
range: 0..3,
style: bold(),
}],
ParagraphKind::Body,
),
(
"a\rb",
vec![Span {
range: 0..3,
style: bold(),
}],
ParagraphKind::Body,
),
(
"a",
vec![Span {
range: 0..1,
style: bold(),
}],
ParagraphKind::Heading { level: 0 },
),
("a", vec![], ParagraphKind::Body),
(
"",
vec![Span {
range: 0..0,
style: bold(),
}],
ParagraphKind::Body,
),
(
"ab",
vec![Span {
range: 0..1,
style: bold(),
}],
ParagraphKind::Body,
),
(
"ab",
vec![Span {
range: 1..2,
style: bold(),
}],
ParagraphKind::Body,
),
(
"ab",
vec![Span {
range: 0..3,
style: bold(),
}],
ParagraphKind::Body,
),
(
"e\u{301}",
vec![
Span {
range: 0..1,
style: bold(),
},
Span {
range: 1..3,
style: bold(),
},
],
ParagraphKind::Body,
),
(
"é",
vec![
Span {
range: 0..1,
style: bold(),
},
Span {
range: 1..2,
style: bold(),
},
],
ParagraphKind::Body,
),
] {
assert_eq!(
Paragraph::from_parts(text.into(), spans, kind),
Err(Error::InvalidFragment)
);
}
}
#[test]
fn document_content_identity_tracks_changes_and_preserves_noops() {
let mut document = Document::from_text("text");
let cloned = document.clone();
assert!(Arc::ptr_eq(&document.identity, &cloned.identity));
let (noop, _) = document
.replace(
Position::default()..document.end(),
"text",
InlineStyle::default(),
)
.unwrap();
assert!(noop.is_empty());
assert!(Arc::ptr_eq(&document.identity, &cloned.identity));
let (delta, _) = document
.replace(document.end()..document.end(), "!", InlineStyle::default())
.unwrap();
assert!(!Arc::ptr_eq(&document.identity, &cloned.identity));
let changed = Arc::clone(&document.identity);
document.replay(&delta, false);
assert!(!Arc::ptr_eq(&document.identity, &changed));
assert!(!Arc::ptr_eq(&document.identity, &cloned.identity));
assert_eq!(document.paragraphs(), cloned.paragraphs());
}
fn bold() -> InlineStyle {
InlineStyle {
bold: true,
..InlineStyle::default()
}
}
fn assert_normalized(document: &Document) {
assert!(!document.paragraphs.is_empty());
for paragraph in document.paragraphs() {
let mut previous_end = 0;
let mut previous_style = None;
for span in paragraph.spans() {
assert_eq!(span.range.start, previous_end);
assert!(span.range.start < span.range.end);
assert!(paragraph.text().is_char_boundary(span.range.start));
assert!(paragraph.text().is_char_boundary(span.range.end));
assert_ne!(Some(span.style), previous_style);
let boundaries: Vec<_> = paragraph
.text()
.grapheme_indices(true)
.map(|(index, _)| index)
.chain([paragraph.text().len()])
.collect();
assert!(boundaries.contains(&span.range.start));
assert!(boundaries.contains(&span.range.end));
previous_end = span.range.end;
previous_style = Some(span.style);
}
assert_eq!(previous_end, paragraph.text().len());
}
}
#[test]
fn plain_text_normalizes_newlines_and_preserves_empty_paragraphs() {
let document = Document::from_text("a\r\nb\rc\n");
assert_eq!(document.plain_text(), "a\nb\nc\n");
assert_eq!(document.paragraphs().len(), 4);
assert_eq!(document.end(), Position::new(3, 0));
assert_eq!(
document
.text(Position::new(0, 1)..Position::new(2, 1))
.unwrap(),
"\nb\nc"
);
assert_normalized(&document);
assert_eq!(Document::new().paragraphs().len(), 1);
}
#[test]
fn positions_require_extended_grapheme_boundaries() {
let document = Document::from_text("e\u{301}👨👩👧👦🇺🇸");
for (byte, _) in document.paragraph(0).unwrap().text().grapheme_indices(true) {
assert!(document.validate_position(Position::new(0, byte)).is_ok());
}
assert!(document.validate_position(document.end()).is_ok());
assert!(document.validate_position(Position::new(0, 1)).is_err());
assert!(document.validate_position(Position::new(0, 2)).is_err());
assert!(document.validate_position(Position::new(0, 7)).is_err());
assert!(document.validate_position(Position::new(1, 0)).is_err());
}
#[test]
fn replacing_preserves_styles_on_surviving_edges() {
let mut document = Document::from_text("before\nafter");
document
.apply_style(
Position::new(0, 0)..Position::new(0, 6),
StylePatch {
bold: Some(true),
..StylePatch::default()
},
)
.unwrap();
document
.apply_style(
Position::new(1, 0)..Position::new(1, 5),
StylePatch {
italic: Some(true),
..StylePatch::default()
},
)
.unwrap();
let (delta, caret) = document
.replace(
Position::new(0, 3)..Position::new(1, 2),
"X",
InlineStyle::default(),
)
.unwrap();
assert_eq!(document.plain_text(), "befXter");
assert_eq!(caret, Position::new(0, 4));
assert_eq!(document.paragraph(0).unwrap().spans().len(), 3);
assert!(document.style_at(Position::new(0, 3)).bold);
assert!(document.style_at(Position::new(0, 5)).italic);
document.replay(&delta, false);
assert_eq!(document.plain_text(), "before\nafter");
document.replay(&delta, true);
assert_eq!(document.plain_text(), "befXter");
assert_normalized(&document);
}
#[test]
fn formatting_merges_runs_and_is_a_noop_when_unchanged() {
let mut document = Document::from_text("abcdef");
let patch = StylePatch {
bold: Some(true),
..StylePatch::default()
};
document
.apply_style(Position::new(0, 2)..Position::new(0, 4), patch)
.unwrap();
assert_eq!(document.paragraph(0).unwrap().spans().len(), 3);
let revision = document.revision();
assert!(
document
.apply_style(Position::new(0, 2)..Position::new(0, 4), patch)
.unwrap()
.is_none()
);
assert_eq!(document.revision(), revision);
document
.apply_style(Position::new(0, 0)..Position::new(0, 6), patch)
.unwrap();
assert_eq!(
document.paragraph(0).unwrap().spans(),
&[Span {
range: 0..6,
style: bold()
}]
);
assert_eq!(document.style_at(Position::new(0, 0)), bold());
assert_eq!(document.style_at(document.end()), bold());
assert_normalized(&document);
}
#[test]
fn inserted_combining_marks_cannot_split_formatting_runs() {
let mut document = Document::from_text("ex");
document
.apply_style(
Position::new(0, 0)..Position::new(0, 1),
StylePatch {
bold: Some(true),
..StylePatch::default()
},
)
.unwrap();
let (_, caret) = document
.replace(
Position::new(0, 1)..Position::new(0, 1),
"\u{301}",
InlineStyle {
italic: true,
..InlineStyle::default()
},
)
.unwrap();
assert_eq!(document.plain_text(), "e\u{301}x");
assert_eq!(caret, Position::new(0, 3));
assert_eq!(document.paragraph(0).unwrap().spans()[0].range, 0..3);
assert_eq!(document.paragraph(0).unwrap().spans()[0].style, bold());
assert_normalized(&document);
}
#[test]
fn emoji_joiner_insertion_snaps_caret_past_new_cluster() {
let mut document = Document::from_text("👩👧");
let (_, caret) = document
.replace(Position::new(0, 4)..Position::new(0, 4), "\u{200d}", bold())
.unwrap();
assert_eq!(document.plain_text(), "👩👧");
assert_eq!(caret, document.end());
assert_eq!(document.paragraph(0).unwrap().spans().len(), 1);
assert_normalized(&document);
}
#[test]
fn joining_paragraphs_also_normalizes_clusters() {
let mut document = Document::from_text("a\n\u{301}b");
document
.apply_style(
Position::new(1, 0)..Position::new(1, 2),
StylePatch {
italic: Some(true),
..StylePatch::default()
},
)
.unwrap();
let (_, caret) = document
.replace(
Position::new(0, 1)..Position::new(1, 0),
"",
InlineStyle::default(),
)
.unwrap();
assert_eq!(document.plain_text(), "a\u{301}b");
assert_eq!(caret, Position::new(0, 3));
assert_normalized(&document);
}
#[test]
fn history_retains_only_changed_paragraphs_and_shares_others() {
let mut document = Document::from_text("zero\none\ntwo\nthree");
let unaffected = Arc::clone(&document.paragraphs()[3]);
let (delta, _) = document
.replace(Position::new(1, 1)..Position::new(1, 2), "N", bold())
.unwrap();
assert_eq!(delta.start, 1);
assert_eq!(delta.before.len(), 1);
assert_eq!(delta.after.len(), 1);
assert!(delta.retained_bytes() > 0);
assert!(Arc::ptr_eq(&unaffected, &document.paragraphs()[3]));
let revision = document.revision();
document.replay(&delta, false);
assert_eq!(document.revision(), revision + 1);
assert!(Arc::ptr_eq(&unaffected, &document.paragraphs()[3]));
assert_eq!(document.plain_text(), "zero\none\ntwo\nthree");
}
#[test]
fn heading_and_list_splits_preserve_paragraph_semantics() {
let mut document = Document::from_text("heading");
document
.set_kind(0..1, ParagraphKind::Heading { level: 2 })
.unwrap();
document
.replace(
document.end()..document.end(),
"\nbody",
InlineStyle::default(),
)
.unwrap();
assert_eq!(
document.paragraph(0).unwrap().kind(),
ParagraphKind::Heading { level: 2 }
);
assert_eq!(document.paragraph(1).unwrap().kind(), ParagraphKind::Body);
document
.set_kind(
1..2,
ParagraphKind::Ordered {
indent: 1,
start: 7,
},
)
.unwrap();
document
.replace(
document.end()..document.end(),
"\nnext\nlast",
InlineStyle::default(),
)
.unwrap();
assert_eq!(
document.paragraph(2).unwrap().kind(),
ParagraphKind::Ordered {
indent: 1,
start: 8
}
);
assert_eq!(
document.paragraph(3).unwrap().kind(),
ParagraphKind::Ordered {
indent: 1,
start: 9
}
);
assert_normalized(&document);
}
#[test]
fn deletion_of_a_complete_leading_paragraph_preserves_suffix_kind() {
let mut document = Document::from_text("first\nheading");
document
.set_kind(1..2, ParagraphKind::Heading { level: 3 })
.unwrap();
document
.replace(
Position::new(0, 0)..Position::new(1, 0),
"",
InlineStyle::default(),
)
.unwrap();
assert_eq!(document.plain_text(), "heading");
assert_eq!(
document.paragraph(0).unwrap().kind(),
ParagraphKind::Heading { level: 3 }
);
}
#[test]
fn noops_do_not_change_revision_or_allocations() {
let mut document = Document::from_text("unchanged");
let original = Arc::clone(&document.paragraphs()[0]);
let (delta, caret) = document
.replace(
Position::default()..document.end(),
"unchanged",
InlineStyle::default(),
)
.unwrap();
assert!(delta.is_empty());
assert_eq!(caret, document.end());
assert_eq!(document.revision(), 0);
assert!(Arc::ptr_eq(&original, &document.paragraphs()[0]));
assert!(
document
.set_kind(0..1, ParagraphKind::Body)
.unwrap()
.is_none()
);
assert!(
document
.apply_style(Position::default()..document.end(), StylePatch::default())
.unwrap()
.is_none()
);
document.replay(&delta, false);
assert_eq!(document.revision(), 0);
}
#[test]
fn invalid_operations_leave_document_unchanged() {
let mut document = Document::from_text("é");
let original = document.clone();
assert!(
document
.replace(Position::new(0, 1)..document.end(), "x", bold())
.is_err()
);
assert!(matches!(
document.set_kind(0..1, ParagraphKind::Heading { level: 0 }),
Err(Error::InvalidHeadingLevel(0))
));
assert!(matches!(
document.set_kind(0..2, ParagraphKind::Body),
Err(Error::InvalidRange)
));
assert_eq!(
document.text(document.end()..Position::default()),
Err(Error::InvalidRange)
);
assert_eq!(document, original);
}
#[test]
fn unicode_replacements_preserve_text_invariants_and_replay_exactly() {
let inputs = [
"",
"abc",
"e\u{301}x",
"👩👧",
"🇺🇸🇨🇦",
"a\n\u{301}b",
"क्\nष",
"\u{600}a",
];
let insertions = ["", "X", "\u{301}", "\u{200d}", "\n", "\r\n", "\n\u{301}"];
for input in inputs {
let mut original = Document::from_text(input);
let mut positions = Vec::new();
for (index, paragraph) in original.paragraphs().iter().enumerate() {
positions.extend(
paragraph
.text()
.grapheme_indices(true)
.map(|(byte, _)| Position::new(index, byte)),
);
positions.push(Position::new(index, paragraph.text().len()));
}
for (index, position) in positions.iter().enumerate() {
if index % 2 == 0
&& let Some(end) = positions.get(index + 1)
{
original
.apply_style(
*position..*end,
StylePatch {
bold: Some(true),
..StylePatch::default()
},
)
.unwrap();
}
}
let plain = original.plain_text();
for (start_index, start) in positions.iter().enumerate() {
for end in &positions[start_index..] {
let global_offset = |position: Position| {
original.paragraphs()[..position.paragraph]
.iter()
.map(|paragraph| paragraph.text().len() + 1)
.sum::<usize>()
+ position.byte
};
for insertion in insertions {
let mut expected = plain.clone();
expected.replace_range(
global_offset(*start)..global_offset(*end),
&normalize_newlines(insertion),
);
let mut edited = original.clone();
let (delta, caret) = edited
.replace(
*start..*end,
insertion,
InlineStyle {
italic: true,
..InlineStyle::default()
},
)
.unwrap();
assert_eq!(edited.plain_text(), expected);
assert!(edited.validate_position(caret).is_ok());
assert_normalized(&edited);
let result = edited.paragraphs().to_vec();
edited.replay(&delta, false);
assert_eq!(edited.paragraphs(), original.paragraphs());
edited.replay(&delta, true);
assert_eq!(edited.paragraphs(), result);
}
}
}
}
}
}