use crate::options::MarkdownOptions;
use crate::span::*;
use crate::spans_renderer::OwnedSpanOutput;
pub struct StreamRenderer {
buffer: String,
options: MarkdownOptions,
current_output: Option<OwnedSpanOutput>,
previous_span_snapshots: Vec<SpanSnapshot>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct SpanSnapshot {
offset: u32,
length: u32,
flags: u32,
block_type: u8,
}
impl StreamRenderer {
pub fn new(options: MarkdownOptions) -> Self {
Self {
buffer: String::new(),
options,
current_output: None,
previous_span_snapshots: Vec::new(),
}
}
pub fn append(&mut self, chunk: &str) -> SpanOutput {
self.buffer.push_str(chunk);
if let Some(ref prev) = self.current_output {
if is_plain_continuation(chunk) && !prev.spans.is_empty() {
if let Some(output) = try_extend_output(prev, chunk) {
self.current_output = Some(output);
let spans = unsafe {
std::slice::from_raw_parts(
self.current_output.as_ref().unwrap().spans.as_ptr(),
self.current_output.as_ref().unwrap().spans.len(),
)
};
self.previous_span_snapshots = snapshots(spans);
return self.current_output.as_ref().unwrap().as_output();
}
}
}
self.current_output = None;
let output = crate::spans_renderer::markdown_to_spans_owned(&self.buffer, &self.options);
let result = output.as_output();
let spans = unsafe {
std::slice::from_raw_parts(result.spans, result.span_count as usize)
};
self.previous_span_snapshots = snapshots(spans);
self.current_output = Some(output);
result
}
pub fn finish(&mut self) -> Option<SpanOutput> {
if self.buffer.is_empty() {
return None;
}
self.current_output = None;
let output = crate::spans_renderer::markdown_to_spans_owned(&self.buffer, &self.options);
let result = output.as_output();
self.current_output = Some(output);
Some(result)
}
pub fn delta(&mut self, chunk: &str) -> SpanDeltaList {
self.buffer.push_str(chunk);
if let Some(ref prev) = self.current_output {
if is_plain_continuation(chunk) && !prev.spans.is_empty() {
if let Some(output) = try_extend_output(prev, chunk) {
let current_spans = unsafe {
std::slice::from_raw_parts(output.spans.as_ptr(), output.spans.len())
};
let delta = compute_delta(&self.previous_span_snapshots, current_spans);
self.previous_span_snapshots = snapshots(current_spans);
self.current_output = Some(output);
return delta;
}
}
}
self.current_output = None;
let output = crate::spans_renderer::markdown_to_spans_owned(&self.buffer, &self.options);
let current_spans = unsafe {
std::slice::from_raw_parts(output.spans.as_ptr(), output.spans.len())
};
let delta = compute_delta(&self.previous_span_snapshots, current_spans);
self.previous_span_snapshots = snapshots(current_spans);
self.current_output = Some(output);
delta
}
pub fn snapshot_owned(&self) -> OwnedSpanOutput {
crate::spans_renderer::markdown_to_spans_owned(&self.buffer, &self.options)
}
pub fn reset(&mut self) {
self.buffer.clear();
self.current_output = None;
self.previous_span_snapshots.clear();
}
pub fn raw_text(&self) -> &str {
&self.buffer
}
pub fn len(&self) -> usize {
self.buffer.len()
}
pub fn is_empty(&self) -> bool {
self.buffer.is_empty()
}
}
fn is_plain_continuation(chunk: &str) -> bool {
for b in chunk.bytes() {
match b {
b'\n' | b'\r' | b'#' | b'*' | b'_' | b'`' | b'[' | b']'
| b'<' | b'>' | b'|' | b'!' | b'~' | b'$' | b'-' | b'+' | b'='
| b'\\' | b'^' => return false,
_ => {}
}
}
!chunk.is_empty()
}
fn try_extend_output(prev: &OwnedSpanOutput, chunk: &str) -> Option<OwnedSpanOutput> {
let chunk_bytes = chunk.as_bytes();
if chunk_bytes.is_empty() {
return None;
}
if let Some(last_span) = prev.spans.last() {
if last_span.block_type == BLOCK_CODE {
return None;
}
if (last_span.flags & FLAG_IMAGE) != 0 {
return None;
}
}
let mut new_text: Vec<u8> = Vec::with_capacity(prev.text.len() + chunk_bytes.len());
new_text.extend_from_slice(&prev.text);
new_text.extend_from_slice(chunk_bytes);
let mut new_spans: Vec<Span> = prev.spans.to_vec();
if let Some(ref mut last) = new_spans.last_mut() {
last.length += chunk.len() as u32;
}
let new_utf16 = prev.utf16_offsets.clone();
Some(OwnedSpanOutput {
text: new_text.into_boxed_slice(),
spans: new_spans.into_boxed_slice(),
extra_data: prev.extra_data.clone(),
utf16_offsets: new_utf16,
})
}
fn snapshots(spans: &[Span]) -> Vec<SpanSnapshot> {
spans
.iter()
.map(|s| SpanSnapshot {
offset: s.offset,
length: s.length,
flags: s.flags,
block_type: s.block_type,
})
.collect()
}
#[derive(Debug, Clone)]
pub struct SpanDeltaList {
pub deltas: Vec<SpanDelta>,
pub locked_text_len: u32,
}
fn compute_delta(previous: &[SpanSnapshot], current: &[Span]) -> SpanDeltaList {
if previous.is_empty() {
let all_spans: Vec<Span> = current.to_vec();
let locked_len = 0u32;
return SpanDeltaList {
deltas: vec![SpanDelta {
kind: SpanDeltaKind::Append,
spans: all_spans,
}],
locked_text_len: locked_len,
};
}
let mut common = 0usize;
let min_len = previous.len().min(current.len());
for i in 0..min_len {
let p = &previous[i];
let c = ¤t[i];
if p.offset == c.offset
&& p.length == c.length
&& p.flags == c.flags
&& p.block_type == c.block_type
{
common = i + 1;
} else {
break;
}
}
let locked_len = if common > 0 && common <= current.len() {
current[common - 1].offset + current[common - 1].length
} else {
0
};
let mut deltas = Vec::new();
if common < previous.len() && common < current.len() {
let replaced_count = (previous.len() - common) as u32;
let new_spans: Vec<Span> = current[common..].to_vec();
if !new_spans.is_empty() {
deltas.push(SpanDelta {
kind: SpanDeltaKind::ReplaceLast {
count: replaced_count,
},
spans: new_spans,
});
}
} else if common < current.len() {
let new_spans: Vec<Span> = current[common..].to_vec();
deltas.push(SpanDelta {
kind: SpanDeltaKind::Append,
spans: new_spans,
});
}
SpanDeltaList {
deltas,
locked_text_len: locked_len,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_stream_basic() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
let output = stream.append("# Hello");
assert!(output.span_count > 0);
let output = stream.append("\nWorld");
assert!(output.span_count > 0);
}
#[test]
fn test_stream_delta() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
stream.append("# Hello");
let delta = stream.delta(" **world**");
assert!(!delta.deltas.is_empty());
}
#[test]
fn test_stream_reset() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
stream.append("hello");
assert!(!stream.is_empty());
stream.reset();
assert!(stream.is_empty());
let output = stream.append("new");
assert!(output.span_count > 0);
}
#[test]
fn test_stream_finish() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
stream.append("hello world");
let final_output = stream.finish();
assert!(final_output.is_some());
}
#[test]
fn test_stream_snapshot() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
stream.append("hello");
let snapshot = stream.snapshot_owned();
let output = snapshot.as_output();
assert!(output.span_count > 0);
}
#[test]
fn test_is_plain_continuation() {
assert!(is_plain_continuation("hello"));
assert!(is_plain_continuation("World 123"));
assert!(is_plain_continuation("foo.bar(baz)"));
assert!(is_plain_continuation("text, with; punctuation: etc"));
assert!(!is_plain_continuation(""));
assert!(!is_plain_continuation("hello\nworld"));
assert!(!is_plain_continuation("hello**bold**"));
assert!(!is_plain_continuation("hello*world*"));
assert!(!is_plain_continuation("code`here`"));
assert!(!is_plain_continuation("link[text](url)"));
assert!(!is_plain_continuation("has#tag"));
assert!(!is_plain_continuation("pipe|table"));
assert!(!is_plain_continuation("$math$"));
}
#[test]
fn test_fast_path_extends_last_span() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
let out1 = stream.append("Hello");
let first_span_count = out1.span_count;
let first_text_len = out1.text_len;
let out2 = stream.append(" World");
assert_eq!(out2.text_len, first_text_len + 6);
assert_eq!(out2.span_count, first_span_count);
}
#[test]
fn test_fast_path_falls_back_on_markdown() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
stream.append("Hello");
let out = stream.append(" **bold**");
assert!(out.span_count > 0);
}
#[test]
fn test_fast_path_correctness() {
let mut stream1 = StreamRenderer::new(MarkdownOptions::default());
stream1.append("Hello");
let mut stream2 = StreamRenderer::new(MarkdownOptions::default());
stream2.append("Hello World");
let out1 = stream1.append(" World");
let out1_text = unsafe {
std::str::from_utf8(std::slice::from_raw_parts(
out1.text, out1.text_len as usize,
)).unwrap()
};
let snapshot = stream2.snapshot_owned();
let out2_full = snapshot.as_output();
let out2_full_text = unsafe {
std::str::from_utf8(std::slice::from_raw_parts(
out2_full.text, out2_full.text_len as usize,
)).unwrap()
};
assert_eq!(out1.text_len, out2_full.text_len);
assert_eq!(out1_text, out2_full_text);
}
#[test]
fn test_fast_path_with_punctuation() {
let mut stream = StreamRenderer::new(MarkdownOptions::default());
stream.append("The ");
let out = stream.append("quick, brown. fox! (test)");
assert!(out.text_len > 0);
assert!(out.span_count > 0);
let text = unsafe {
std::str::from_utf8(std::slice::from_raw_parts(
out.text, out.text_len as usize,
)).unwrap()
};
assert!(text.contains("quick, brown. fox! (test)"));
}
}