use serde::{Deserialize, Serialize};
use crate::entities::*;
use crate::format_runs::{InlineContent, InlineSegment};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FragmentData {
pub blocks: Vec<FragmentBlock>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub tables: Vec<FragmentTable>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FragmentTable {
pub rows: usize,
pub columns: usize,
pub cells: Vec<FragmentTableCell>,
#[serde(default)]
pub block_insert_index: usize,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_border: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_cell_spacing: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_cell_padding: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_width: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_alignment: Option<Alignment>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub column_widths: Vec<i64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FragmentTableCell {
pub row: usize,
pub column: usize,
pub row_span: usize,
pub column_span: usize,
pub blocks: Vec<FragmentBlock>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_padding: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_border: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_vertical_alignment: Option<CellVerticalAlignment>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_background_color: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FragmentBlock {
pub plain_text: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub elements: Vec<FragmentElement>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub heading_level: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub list: Option<FragmentList>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub alignment: Option<Alignment>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub indent: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub text_indent: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub marker: Option<MarkerType>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub top_margin: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bottom_margin: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub left_margin: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub right_margin: Option<i64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub tab_positions: Vec<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub line_height: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub non_breakable_lines: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub page_break_before: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub direction: Option<TextDirection>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub background_color: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub is_code_block: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code_language: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hyphenate: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub language: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FragmentElement {
pub content: InlineContent,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_family: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_point_size: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_weight: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_bold: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_italic: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_underline: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_overline: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_font_strikeout: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_letter_spacing: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_word_spacing: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_anchor_href: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub fmt_anchor_names: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_is_anchor: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_tooltip: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_underline_style: Option<UnderlineStyle>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fmt_vertical_alignment: Option<CharVerticalAlignment>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FragmentList {
pub style: ListStyle,
pub indent: i64,
pub prefix: String,
pub suffix: String,
}
impl FragmentElement {
pub fn from_segment(seg: &InlineSegment) -> Self {
FragmentElement {
content: seg.content.clone(),
fmt_font_family: seg.fmt_font_family.clone(),
fmt_font_point_size: seg.fmt_font_point_size,
fmt_font_weight: seg.fmt_font_weight,
fmt_font_bold: seg.fmt_font_bold,
fmt_font_italic: seg.fmt_font_italic,
fmt_font_underline: seg.fmt_font_underline,
fmt_font_overline: seg.fmt_font_overline,
fmt_font_strikeout: seg.fmt_font_strikeout,
fmt_letter_spacing: seg.fmt_letter_spacing,
fmt_word_spacing: seg.fmt_word_spacing,
fmt_anchor_href: seg.fmt_anchor_href.clone(),
fmt_anchor_names: seg.fmt_anchor_names.clone(),
fmt_is_anchor: seg.fmt_is_anchor,
fmt_tooltip: seg.fmt_tooltip.clone(),
fmt_underline_style: seg.fmt_underline_style.clone(),
fmt_vertical_alignment: seg.fmt_vertical_alignment.clone(),
}
}
}
impl FragmentBlock {
pub fn is_inline_only(&self) -> bool {
self.heading_level.is_none()
&& self.list.is_none()
&& self.alignment.is_none()
&& self.indent.unwrap_or(0) == 0
&& self.text_indent.unwrap_or(0) == 0
&& self.marker.is_none()
&& self.top_margin.is_none()
&& self.bottom_margin.is_none()
&& self.left_margin.is_none()
&& self.right_margin.is_none()
&& self.line_height.is_none()
&& self.non_breakable_lines.is_none()
&& self.direction.is_none()
&& self.background_color.is_none()
&& self.is_code_block.is_none()
&& self.code_language.is_none()
&& self.hyphenate.is_none()
&& self.language.is_none()
}
}
impl FragmentList {
pub fn from_entity(list: &List) -> Self {
FragmentList {
style: list.style.clone(),
indent: list.indent,
prefix: list.prefix.clone(),
suffix: list.suffix.clone(),
}
}
pub fn to_entity(&self) -> List {
List {
id: 0,
created_at: chrono::Utc::now(),
updated_at: chrono::Utc::now(),
style: self.style.clone(),
indent: self.indent,
prefix: self.prefix.clone(),
suffix: self.suffix.clone(),
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FragmentQuoting {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
blocks: Vec<QuotedEntry>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
tables: Vec<QuotedEntry>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct QuotedEntry {
index: usize,
depth: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
role: Option<SemanticRole>,
}
impl FragmentQuoting {
pub fn is_empty(&self) -> bool {
self.blocks.is_empty() && self.tables.is_empty()
}
pub fn set_block(&mut self, index: usize, depth: u32, role: Option<SemanticRole>) {
set_entry(&mut self.blocks, index, depth, role);
}
pub fn set_table(&mut self, index: usize, depth: u32) {
set_entry(&mut self.tables, index, depth, None);
}
pub fn block_depth(&self, index: usize) -> u32 {
find_entry(&self.blocks, index).map_or(0, |entry| entry.depth)
}
pub fn block_role(&self, index: usize) -> Option<&SemanticRole> {
find_entry(&self.blocks, index).and_then(|entry| entry.role.as_ref())
}
pub fn table_depth(&self, index: usize) -> u32 {
find_entry(&self.tables, index).map_or(0, |entry| entry.depth)
}
}
fn set_entry(entries: &mut Vec<QuotedEntry>, index: usize, depth: u32, role: Option<SemanticRole>) {
let at = entries.partition_point(|entry| entry.index < index);
let replaces = entries.get(at).is_some_and(|entry| entry.index == index);
if depth == 0 {
if replaces {
entries.remove(at);
}
return;
}
let entry = QuotedEntry { index, depth, role };
if replaces {
entries[at] = entry;
} else {
entries.insert(at, entry);
}
}
fn find_entry(entries: &[QuotedEntry], index: usize) -> Option<&QuotedEntry> {
entries
.binary_search_by_key(&index, |entry| entry.index)
.ok()
.and_then(|at| entries.get(at))
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct CarriedFragment {
pub data: FragmentData,
pub quoting: FragmentQuoting,
pub replaces_text: bool,
pub whole_text: bool,
}
#[derive(Serialize)]
struct CarriedRef<'a> {
#[serde(skip_serializing_if = "is_false")]
replaces_text: bool,
#[serde(skip_serializing_if = "is_false")]
whole_text: bool,
blocks: &'a [FragmentBlock],
#[serde(skip_serializing_if = "no_tables")]
tables: &'a [FragmentTable],
#[serde(skip_serializing_if = "no_quoting")]
quoting: &'a FragmentQuoting,
}
#[derive(Deserialize)]
struct Carried {
#[serde(default)]
replaces_text: bool,
#[serde(default)]
whole_text: bool,
blocks: Vec<FragmentBlock>,
#[serde(default)]
tables: Vec<FragmentTable>,
#[serde(default)]
quoting: FragmentQuoting,
}
fn is_false(value: &bool) -> bool {
!*value
}
fn no_tables(tables: &&[FragmentTable]) -> bool {
tables.is_empty()
}
fn no_quoting(quoting: &&FragmentQuoting) -> bool {
quoting.is_empty()
}
pub fn fragment_to_json(
data: &FragmentData,
quoting: &FragmentQuoting,
) -> serde_json::Result<String> {
carried_to_json(data, quoting, false)
}
pub fn whole_text_to_json(
data: &FragmentData,
quoting: &FragmentQuoting,
) -> serde_json::Result<String> {
carried_to_json(data, quoting, true)
}
fn carried_to_json(
data: &FragmentData,
quoting: &FragmentQuoting,
whole_text: bool,
) -> serde_json::Result<String> {
serde_json::to_string(&CarriedRef {
replaces_text: false,
whole_text,
blocks: &data.blocks,
tables: &data.tables,
quoting,
})
}
pub fn fragment_from_json(json: &str) -> serde_json::Result<CarriedFragment> {
let carried: Carried = serde_json::from_str(json)?;
Ok(CarriedFragment {
data: FragmentData {
blocks: carried.blocks,
tables: carried.tables,
},
quoting: carried.quoting,
replaces_text: carried.replaces_text,
whole_text: carried.whole_text,
})
}
const REPLACES_TEXT_MARK: &str = "\"replaces_text\":true";
const WHOLE_TEXT_MARK: &str = "\"whole_text\":true";
pub fn replacing_the_text(json: &str) -> String {
marked(json, REPLACES_TEXT_MARK)
}
pub fn as_a_whole_text(json: &str) -> String {
marked(json, WHOLE_TEXT_MARK)
}
fn marked(json: &str, mark: &str) -> String {
let Some(rest) = json.strip_prefix('{') else {
return json.to_string();
};
let mut leading = rest;
while let Some(present) = [REPLACES_TEXT_MARK, WHOLE_TEXT_MARK]
.into_iter()
.find(|present| leading.starts_with(present))
{
if present == mark {
return json.to_string();
}
let after = &leading[present.len()..];
leading = after.strip_prefix(',').unwrap_or(after);
}
let separator = if rest.trim_start().starts_with('}') {
""
} else {
","
};
let mut marked = String::with_capacity(json.len() + mark.len() + 1);
marked.push('{');
marked.push_str(mark);
marked.push_str(separator);
marked.push_str(rest);
marked
}
#[cfg(test)]
mod tests {
use super::*;
fn block(text: &str) -> FragmentBlock {
FragmentBlock {
plain_text: text.to_string(),
elements: Vec::new(),
heading_level: None,
list: None,
alignment: None,
indent: None,
text_indent: None,
marker: None,
top_margin: None,
bottom_margin: None,
left_margin: None,
right_margin: None,
tab_positions: Vec::new(),
line_height: None,
non_breakable_lines: None,
page_break_before: None,
direction: None,
background_color: None,
is_code_block: None,
code_language: None,
hyphenate: None,
language: None,
}
}
fn data() -> FragmentData {
FragmentData {
blocks: vec![block("One"), block("Two"), block("Three")],
tables: Vec::new(),
}
}
#[test]
fn an_unquoted_fragment_is_written_as_its_data_alone() {
let data = data();
let carried = fragment_to_json(&data, &FragmentQuoting::default()).unwrap();
assert_eq!(carried, serde_json::to_string(&data).unwrap());
}
#[test]
fn the_quotations_travel_beside_the_data() {
let data = data();
let mut quoting = FragmentQuoting::default();
quoting.set_block(2, 1, None);
quoting.set_block(1, 2, Some(SemanticRole::Epigraph));
quoting.set_block(0, 0, None);
let json = fragment_to_json(&data, "ing).unwrap();
let back = fragment_from_json(&json).unwrap();
assert_eq!(back.quoting, quoting);
assert_eq!(back.quoting.block_depth(0), 0);
assert_eq!(back.quoting.block_depth(1), 2);
assert_eq!(back.quoting.block_role(1), Some(&SemanticRole::Epigraph));
assert_eq!(back.quoting.block_depth(2), 1);
assert!(!back.replaces_text);
let alone: FragmentData = serde_json::from_str(&json).unwrap();
assert_eq!(alone.blocks.len(), 3);
}
#[test]
fn a_fragment_marked_as_replacing_a_text_reads_back_marked() {
let json = fragment_to_json(&data(), &FragmentQuoting::default()).unwrap();
let marked = replacing_the_text(&json);
assert!(fragment_from_json(&marked).unwrap().replaces_text);
assert_eq!(replacing_the_text(&marked), marked);
let alone: FragmentData = serde_json::from_str(&marked).unwrap();
assert_eq!(alone.blocks.len(), 3);
assert!(
fragment_from_json(&replacing_the_text("{\"blocks\":[]}"))
.is_ok_and(|f| f.replaces_text)
);
assert_eq!(replacing_the_text("not json"), "not json");
}
#[test]
fn a_whole_text_reads_back_as_one_beside_the_mark_of_a_text_replaced() {
let quoting = FragmentQuoting::default();
let plain = fragment_to_json(&data(), "ing).unwrap();
assert!(!fragment_from_json(&plain).unwrap().whole_text);
let written = whole_text_to_json(&data(), "ing).unwrap();
let spliced = as_a_whole_text(&plain);
for whole in [&written, &spliced] {
let back = fragment_from_json(whole).unwrap();
assert!(back.whole_text && !back.replaces_text, "{whole}");
let replacing = replacing_the_text(whole);
let back = fragment_from_json(&replacing).unwrap();
assert!(back.whole_text && back.replaces_text, "{replacing}");
assert_eq!(as_a_whole_text(&replacing), replacing);
assert_eq!(replacing_the_text(&replacing), replacing);
let alone: FragmentData = serde_json::from_str(&replacing).unwrap();
assert_eq!(alone.blocks.len(), 3);
}
let replacing_first = as_a_whole_text(&replacing_the_text(&plain));
let back = fragment_from_json(&replacing_first).unwrap();
assert!(back.whole_text && back.replaces_text, "{replacing_first}");
assert_eq!(as_a_whole_text(&replacing_first), replacing_first);
assert_eq!(replacing_the_text(&replacing_first), replacing_first);
assert_eq!(as_a_whole_text("not json"), "not json");
}
}