6ef13b2cc8a6
model_bridge.rs
//! Bounded conversion between craft-wordmodel and WordCraft's document model.
use std::collections::HashMap;
use std::sync::Arc;
use craft_docx::DocxError;
use serde::Serialize;
use serde::de::DeserializeOwned;
pub(crate) fn convert<T, U>(value: T) -> Result<U, DocxError>
where
T: Serialize,
U: DeserializeOwned,
{
let bytes = serde_json::to_vec(&value).map_err(|error| DocxError::Xml(format!("shared model conversion: {error}")))?;
drop(value);
serde_json::from_slice(&bytes).map_err(|error| DocxError::Xml(format!("shared model conversion: {error}")))
}
pub(crate) fn convert_ref<T, U>(value: &T) -> Result<U, DocxError>
where
T: Serialize + ?Sized,
U: DeserializeOwned,
{
let bytes = serde_json::to_vec(value).map_err(|error| DocxError::Xml(format!("shared model conversion: {error}")))?;
serde_json::from_slice(&bytes).map_err(|error| DocxError::Xml(format!("shared model conversion: {error}")))
}
// ---------------------------------------------------------------------------
// From Shared Model -> WordCraft Document
// ---------------------------------------------------------------------------
type GraphicCache = HashMap<usize, Arc<wordcraft_doc::graphic::Graphic>>;
fn blocks_from_shared(source: craft_wordmodel::Blocks, graphics: &mut GraphicCache) -> Result<wordcraft_doc::Blocks, DocxError> {
source
.into_iter()
.map(|block| {
let block = Arc::try_unwrap(block).unwrap_or_else(|shared| (*shared).clone());
block_value_from_shared(block, graphics).map(Arc::new)
})
.collect()
}
fn block_value_from_shared(source: craft_wordmodel::Block, graphics: &mut GraphicCache) -> Result<wordcraft_doc::Block, DocxError> {
match source {
craft_wordmodel::Block::Para(paragraph) => paragraph_value_from_shared(paragraph, graphics).map(wordcraft_doc::Block::Para),
craft_wordmodel::Block::Table(table) => table_value_from_shared(table, graphics).map(wordcraft_doc::Block::Table),
}
}
fn paragraph_value_from_shared(
source: craft_wordmodel::para::Paragraph,
graphics: &mut GraphicCache,
) -> Result<wordcraft_doc::para::Paragraph, DocxError> {
let craft_wordmodel::para::Paragraph { text, runs, props, mark, objects, section, .. } = source;
let mut paragraph = wordcraft_doc::para::Paragraph::new();
paragraph.text = text;
paragraph.runs =
runs.into_iter().map(|run| Ok(wordcraft_doc::para::Run { len: run.len, props: convert(run.props)? })).collect::<Result<_, DocxError>>()?;
paragraph.props = convert(props)?;
paragraph.mark = convert(mark)?;
paragraph.objects = objects.into_iter().map(|o| object_value_from_shared(o, graphics)).collect::<Result<_, _>>()?;
paragraph.section = section.map(|section| convert(*section).map(Box::new)).transpose()?;
Ok(paragraph)
}
fn object_value_from_shared(
source: craft_wordmodel::para::InlineObject,
graphics: &mut GraphicCache,
) -> Result<wordcraft_doc::para::InlineObject, DocxError> {
use craft_wordmodel::para::InlineObject as Source;
use wordcraft_doc::para::InlineObject as Target;
match source {
Source::Image { media, w, h, alt, float, crop, fx, ole } => Ok(Target::Image {
media,
w,
h,
alt,
float: convert(float)?,
crop,
fx: convert(fx)?,
ole: ole.map(|o| convert(Arc::try_unwrap(o).unwrap_or_else(|s| (*s).clone())).map(Arc::new)).transpose()?,
}),
Source::Graphic { w, h, alt, float, graphic } => {
let key = Arc::as_ptr(&graphic) as usize;
let graphic = if let Some(cached) = graphics.get(&key) {
Arc::clone(cached)
} else {
let converted: Arc<wordcraft_doc::graphic::Graphic> = Arc::new(convert(Arc::try_unwrap(graphic).unwrap_or_else(|s| (*s).clone()))?);
graphics.insert(key, Arc::clone(&converted));
converted
};
Ok(Target::Graphic { w, h, alt, float: convert(float)?, graphic })
}
// This model has no picture frame shape: DrawingML's `frame` preset is read as a
// rectangle, without the frame's border width.
mut shape @ Source::Shape { kind: craft_wordmodel::para::ShapeKind::Frame, .. } => {
if let Source::Shape { kind, extra, .. } = &mut shape {
*kind = craft_wordmodel::para::ShapeKind::Rectangle;
extra.corner = None;
}
convert(shape)
}
Source::Group { w, h, float, ch_w, ch_h, children, canvas } => Ok(Target::Group {
w,
h,
float: convert(float)?,
ch_w,
ch_h,
children: children.into_iter().map(|c| group_child_value_from_shared(c, graphics)).collect::<Result<_, _>>()?,
canvas: canvas.map(convert).transpose()?,
}),
other => convert(other),
}
}
fn group_child_value_from_shared(
source: craft_wordmodel::para::GroupChild,
graphics: &mut GraphicCache,
) -> Result<wordcraft_doc::para::GroupChild, DocxError> {
Ok(wordcraft_doc::para::GroupChild { x: source.x, y: source.y, obj: object_value_from_shared(source.obj, graphics)? })
}
fn table_value_from_shared(source: craft_wordmodel::table::Table, graphics: &mut GraphicCache) -> Result<wordcraft_doc::table::Table, DocxError> {
Ok(wordcraft_doc::table::Table {
props: convert(source.props)?,
grid: source.grid,
rows: source.rows.into_iter().map(|r| row_value_from_shared(r, graphics)).collect::<Result<_, _>>()?,
controls: convert(source.controls)?,
})
}
fn row_value_from_shared(source: craft_wordmodel::table::Row, graphics: &mut GraphicCache) -> Result<wordcraft_doc::table::Row, DocxError> {
Ok(wordcraft_doc::table::Row {
props: convert(source.props)?,
cells: source.cells.into_iter().map(|c| cell_value_from_shared(c, graphics)).collect::<Result<_, _>>()?,
controls: convert(source.controls)?,
})
}
fn cell_value_from_shared(source: craft_wordmodel::table::Cell, graphics: &mut GraphicCache) -> Result<wordcraft_doc::table::Cell, DocxError> {
Ok(wordcraft_doc::table::Cell {
props: convert(source.props)?,
blocks: blocks_from_shared(source.blocks, graphics)?,
controls: convert(source.controls)?,
})
}
fn part_value_from_shared(source: craft_wordmodel::Part, graphics: &mut GraphicCache) -> Result<wordcraft_doc::Part, DocxError> {
Ok(wordcraft_doc::Part { kind: convert(source.kind)?, blocks: blocks_from_shared(source.blocks, graphics)?, body: convert(source.body)? })
}
fn glossary_value_from_shared(
source: craft_wordmodel::BuildingBlock,
graphics: &mut GraphicCache,
) -> Result<wordcraft_doc::BuildingBlock, DocxError> {
Ok(wordcraft_doc::BuildingBlock {
name: source.name,
gallery: source.gallery,
category: source.category,
description: source.description,
guid: source.guid,
style: source.style,
types: source.types,
behaviors: source.behaviors,
blocks: blocks_from_shared(source.blocks, graphics)?,
})
}
fn missing_pictures_from_shared(source: craft_wordmodel::MissingPictures) -> Result<wordcraft_doc::MissingPictures, DocxError> {
let mut target = wordcraft_doc::MissingPictures::default();
target.truncated = source.truncated;
target.total = source.total;
target.main = source.main;
target.part_names = source.part_names;
target.media_parts = source.media_parts;
for item in source.list {
target.list.push(convert(item)?);
}
Ok(target)
}
/// Converts the shared reader's model without copying the full document or its embedded media.
pub fn from_shared_model(mut source: craft_wordmodel::Document) -> Result<wordcraft_doc::Document, DocxError> {
let mut fit_state = None;
let fit_key = source.passthrough.keys().find(|k| k.eq_ignore_ascii_case(crate::fit::PART)).cloned();
if let Some(key) = fit_key
&& let Some(xml_bytes) = source.passthrough.get(&key)
&& let Some(state) = crate::fit::read_from_bytes(xml_bytes)
{
fit_state = Some(state);
source.passthrough.remove(&key);
}
let craft_wordmodel::Document {
body,
last_section,
parts,
styles,
numbering,
comments,
revisions,
settings,
core,
sources,
custom_props,
footnote_separators,
endnote_separators,
media,
passthrough,
glossary,
missing_pictures,
..
} = source;
let mut graphics = GraphicCache::new();
let mut document = wordcraft_doc::Document::new();
document.body = blocks_from_shared(body, &mut graphics)?;
document.last_section = convert(last_section)?;
document.parts = parts.into_iter().map(|(id, part)| Ok((id, part_value_from_shared(part, &mut graphics)?))).collect::<Result<_, DocxError>>()?;
document.styles = Arc::new(convert((*styles).clone())?);
document.numbering = Arc::new(convert((*numbering).clone())?);
document.comments = convert(comments)?;
document.revisions = convert(revisions)?;
document.settings = convert(settings)?;
document.core = convert(core)?;
document.sources = convert(sources)?;
document.custom_props = convert(custom_props)?;
document.footnote_separators = convert(footnote_separators)?;
document.endnote_separators = convert(endnote_separators)?;
document.media = media;
document.passthrough = passthrough;
document.glossary = glossary.into_iter().map(|g| glossary_value_from_shared(g, &mut graphics)).collect::<Result<_, _>>()?;
document.missing_pictures = missing_pictures_from_shared(missing_pictures)?;
document.fit_state = fit_state;
Ok(document)
}
// ---------------------------------------------------------------------------
// To Shared Model (from WordCraft Document)
// ---------------------------------------------------------------------------
fn blocks_to_shared(source: &wordcraft_doc::Blocks) -> Result<craft_wordmodel::Blocks, DocxError> {
source.iter().map(|block| block_value_to_shared(block).map(Arc::new)).collect()
}
fn block_value_to_shared(source: &wordcraft_doc::Block) -> Result<craft_wordmodel::Block, DocxError> {
match source {
wordcraft_doc::Block::Para(paragraph) => paragraph_value_to_shared(paragraph).map(craft_wordmodel::Block::Para),
wordcraft_doc::Block::Table(table) => table_value_to_shared(table).map(craft_wordmodel::Block::Table),
}
}
fn finite(v: f32) -> f32 {
if v.is_finite() { v } else { 0.0 }
}
fn sanitize_para_props(mut props: wordcraft_doc::ParaProps) -> wordcraft_doc::ParaProps {
if let Some(ls) = &mut props.line_spacing {
match ls {
wordcraft_doc::props::LineSpacing::Multiple(v) => *v = finite(*v),
wordcraft_doc::props::LineSpacing::Exactly(v) => *v = finite(*v),
wordcraft_doc::props::LineSpacing::AtLeast(v) => *v = finite(*v),
}
}
for field in [&mut props.indent_left, &mut props.indent_right, &mut props.indent_first, &mut props.space_before, &mut props.space_after] {
if let Some(v) = field
&& !v.is_finite()
{
*v = 0.0;
}
}
props
}
fn sanitize_char_props(mut props: wordcraft_doc::CharProps) -> wordcraft_doc::CharProps {
for field in [&mut props.size, &mut props.spacing] {
if let Some(v) = field
&& !v.is_finite()
{
*v = 0.0;
}
}
props
}
fn paragraph_value_to_shared(source: &wordcraft_doc::para::Paragraph) -> Result<craft_wordmodel::para::Paragraph, DocxError> {
let mut paragraph = craft_wordmodel::para::Paragraph::new();
paragraph.text = source.text.clone();
paragraph.runs = source
.runs
.iter()
.map(|run| Ok(craft_wordmodel::para::Run { len: run.len, props: convert(sanitize_char_props(run.props.clone()))? }))
.collect::<Result<_, DocxError>>()?;
paragraph.props = convert(sanitize_para_props(source.props.clone()))?;
paragraph.mark = convert(sanitize_char_props(source.mark.clone()))?;
paragraph.objects = source.objects.iter().map(object_value_to_shared).collect::<Result<_, _>>()?;
paragraph.section = source.section.as_ref().map(|section| convert_ref(section.as_ref()).map(Box::new)).transpose()?;
Ok(paragraph)
}
fn object_value_to_shared(source: &wordcraft_doc::para::InlineObject) -> Result<craft_wordmodel::para::InlineObject, DocxError> {
use craft_wordmodel::para::InlineObject as Target;
use wordcraft_doc::para::InlineObject as Source;
match source {
Source::Image { media, w, h, alt, float, crop, fx, ole } => Ok(Target::Image {
media: media.clone(),
w: finite(*w),
h: finite(*h),
alt: alt.clone(),
float: convert_ref(float)?,
crop: [finite(crop[0]), finite(crop[1]), finite(crop[2]), finite(crop[3])],
fx: convert_ref(fx)?,
ole: ole.as_ref().map(|o| convert_ref(o.as_ref()).map(Arc::new)).transpose()?,
}),
Source::Group { w, h, float, ch_w, ch_h, children, canvas } => Ok(Target::Group {
w: *w,
h: *h,
float: convert_ref(float)?,
ch_w: *ch_w,
ch_h: *ch_h,
children: children.iter().map(group_child_value_to_shared).collect::<Result<_, _>>()?,
canvas: canvas.as_ref().map(convert_ref).transpose()?,
}),
other => convert_ref(other),
}
}
fn group_child_value_to_shared(source: &wordcraft_doc::para::GroupChild) -> Result<craft_wordmodel::para::GroupChild, DocxError> {
Ok(craft_wordmodel::para::GroupChild { x: source.x, y: source.y, obj: object_value_to_shared(&source.obj)? })
}
fn table_value_to_shared(source: &wordcraft_doc::table::Table) -> Result<craft_wordmodel::table::Table, DocxError> {
Ok(craft_wordmodel::table::Table {
props: convert_ref(&source.props)?,
grid: source.grid.clone(),
rows: source.rows.iter().map(row_value_to_shared).collect::<Result<_, _>>()?,
controls: convert_ref(&source.controls)?,
})
}
fn row_value_to_shared(source: &wordcraft_doc::table::Row) -> Result<craft_wordmodel::table::Row, DocxError> {
Ok(craft_wordmodel::table::Row {
props: convert_ref(&source.props)?,
cells: source.cells.iter().map(cell_value_to_shared).collect::<Result<_, _>>()?,
controls: convert_ref(&source.controls)?,
})
}
fn cell_value_to_shared(source: &wordcraft_doc::table::Cell) -> Result<craft_wordmodel::table::Cell, DocxError> {
Ok(craft_wordmodel::table::Cell {
props: convert_ref(&source.props)?,
blocks: blocks_to_shared(&source.blocks)?,
controls: convert_ref(&source.controls)?,
})
}
fn part_value_to_shared(source: &wordcraft_doc::Part) -> Result<craft_wordmodel::Part, DocxError> {
Ok(craft_wordmodel::Part { kind: convert_ref(&source.kind)?, blocks: blocks_to_shared(&source.blocks)?, body: convert_ref(&source.body)? })
}
fn glossary_value_to_shared(source: &wordcraft_doc::BuildingBlock) -> Result<craft_wordmodel::BuildingBlock, DocxError> {
Ok(craft_wordmodel::BuildingBlock {
name: source.name.clone(),
gallery: source.gallery.clone(),
category: source.category.clone(),
description: source.description.clone(),
guid: source.guid.clone(),
style: source.style.clone(),
types: source.types.clone(),
behaviors: source.behaviors.clone(),
blocks: blocks_to_shared(&source.blocks)?,
})
}
fn missing_pictures_to_shared(source: &wordcraft_doc::MissingPictures) -> Result<craft_wordmodel::MissingPictures, DocxError> {
let mut target = craft_wordmodel::MissingPictures::default();
target.truncated = source.truncated;
target.total = source.total;
target.main = source.main.clone();
target.part_names = source.part_names.clone();
target.media_parts = source.media_parts.clone();
for item in &source.list {
target.list.push(convert_ref(item)?);
}
Ok(target)
}
/// Converts a WordCraft document to the shared model for serialization.
pub fn to_shared_model(source: &wordcraft_doc::Document) -> Result<craft_wordmodel::Document, DocxError> {
let mut document = craft_wordmodel::Document::new();
document.body = blocks_to_shared(&source.body)?;
document.last_section = convert_ref(&source.last_section)?;
document.parts = source.parts.iter().map(|(&id, part)| Ok((id, part_value_to_shared(part)?))).collect::<Result<_, DocxError>>()?;
document.styles = Arc::new(convert_ref(source.styles.as_ref())?);
document.numbering = Arc::new(convert_ref(source.numbering.as_ref())?);
document.comments = convert_ref(&source.comments)?;
document.revisions = convert_ref(&source.revisions)?;
document.settings = convert_ref(&source.settings)?;
document.core = convert_ref(&source.core)?;
document.sources = convert_ref(&source.sources)?;
document.custom_props = convert_ref(&source.custom_props)?;
document.footnote_separators = convert_ref(&source.footnote_separators)?;
document.endnote_separators = convert_ref(&source.endnote_separators)?;
document.media = source.media.clone();
document.passthrough = source.passthrough.clone();
document.glossary = source.glossary.iter().map(glossary_value_to_shared).collect::<Result<_, _>>()?;
document.missing_pictures = missing_pictures_to_shared(&source.missing_pictures)?;
// Handle fit_state preservation through custom XML passthrough
if let Some(fit) = &source.fit_state {
let xml = crate::fit::write(fit)?;
document.passthrough.insert(crate::fit::PART.into(), Arc::new(xml));
const CUSTOM_XML_ROOTS: &str = "wordcraft:customXml.roots";
const EMBEDDED_PARTS: &str = "wordcraft:embedded.parts";
let manifest_entry = format!("P\t{}\tapplication/xml\n", crate::fit::PART);
let manifest = match document.passthrough.get_mut(EMBEDDED_PARTS) {
Some(existing) => {
let mut text = String::from_utf8_lossy(existing).to_string();
if !text.contains(crate::fit::PART) {
text.push_str(&manifest_entry);
}
Arc::new(text.into_bytes())
}
None => Arc::new(manifest_entry.into_bytes()),
};
document.passthrough.insert(EMBEDDED_PARTS.into(), manifest);
let root_entry = format!("D\thttp://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml\t{}\n", crate::fit::PART);
let roots = match document.passthrough.get_mut(CUSTOM_XML_ROOTS) {
Some(existing) => {
let mut text = String::from_utf8_lossy(existing).to_string();
if !text.contains(crate::fit::PART) {
text.push_str(&root_entry);
}
Arc::new(text.into_bytes())
}
None => Arc::new(root_entry.into_bytes()),
};
document.passthrough.insert(CUSTOM_XML_ROOTS.into(), roots);
}
Ok(document)
}
#[cfg(test)]
mod tests {
use super::*;
fn doc_with(objects: Vec<craft_wordmodel::para::InlineObject>) -> craft_wordmodel::Document {
let mut source = craft_wordmodel::Document::new();
let mut para = craft_wordmodel::para::Paragraph::new();
para.objects = objects;
source.body = vec![Arc::new(craft_wordmodel::Block::Para(para))];
source
}
fn objects(doc: &wordcraft_doc::Document) -> Vec<wordcraft_doc::para::InlineObject> {
doc.body.first().and_then(|b| b.as_para()).map(|p| p.objects.clone()).unwrap_or_default()
}
fn chart_object(spec: craft_wordmodel::chart::ChartSpec) -> craft_wordmodel::para::InlineObject {
let graphic = craft_wordmodel::graphic::Graphic { chart: Some(Arc::new(spec)), ..Default::default() };
craft_wordmodel::para::InlineObject::Graphic { w: 100.0, h: 60.0, alt: String::new(), float: Default::default(), graphic: Arc::new(graphic) }
}
fn charts(doc: &wordcraft_doc::Document) -> Vec<Option<wordcraft_doc::chart::ChartSpec>> {
objects(doc)
.iter()
.filter_map(|o| match o {
wordcraft_doc::para::InlineObject::Graphic { graphic, .. } => Some(graphic.chart.as_deref().cloned()),
_ => None,
})
.collect()
}
/// A picture frame shape opens as a rectangle instead of failing the whole document.
#[test]
fn a_frame_shape_reads_as_a_rectangle() {
let shape = |kind| craft_wordmodel::para::InlineObject::Shape {
kind,
w: 40.0,
h: 30.0,
fill: None,
stroke: None,
stroke_width: 1.0,
float: Default::default(),
story: None,
freeform: None,
effects: Default::default(),
extra: craft_wordmodel::connector::ShapeExtra { corner: Some(2604), ..Default::default() },
};
let doc = from_shared_model(doc_with(vec![shape(craft_wordmodel::para::ShapeKind::Frame)])).expect("from_shared_model");
let found = objects(&doc);
let [wordcraft_doc::para::InlineObject::Shape { kind, w, extra, .. }] = found.as_slice() else { panic!("{found:?}") };
assert_eq!((*kind, *w, extra.corner), (wordcraft_doc::para::ShapeKind::Rectangle, 40.0, None));
}
/// A chart's series formatting and axis settings survive the trip through this model, so
/// saving writes the chart part the reader read.
#[test]
fn chart_formatting_survives_the_bridge() {
use craft_wordmodel::chart::{ChartSpec, ChartType};
let mut formatted = ChartSpec::sample(ChartType::Line);
formatted.series[0].fill = Some(craft_wordmodel::props::Rgb(0x12, 0x34, 0x56));
formatted.series[0].line_w = Some(2.5);
formatted.series[1].smooth = true;
formatted.series[1].markers = Some(true);
formatted.series[2].labels = Some(true);
formatted.series[2].fmt = Some("0.0".into());
formatted.val_axis.title = Some("Sales".into());
formatted.val_axis.min = Some(0.0);
formatted.cat_axis.gridlines = true;
let mut scatter_lines = ChartSpec::sample(ChartType::Scatter);
scatter_lines.series[0].no_line = false;
let all = [formatted, ChartSpec::sample(ChartType::Scatter), ChartSpec::sample(ChartType::Pie), scatter_lines];
let doc = from_shared_model(doc_with(all.iter().cloned().map(chart_object).collect())).expect("from_shared_model");
assert!(charts(&doc).iter().all(Option::is_some));
let back = to_shared_model(&doc).expect("to_shared_model");
let back: Vec<ChartSpec> = back
.body
.first()
.and_then(|b| b.as_para())
.map(|p| {
p.objects
.iter()
.filter_map(|o| match o {
craft_wordmodel::para::InlineObject::Graphic { graphic, .. } => graphic.chart.as_deref().cloned(),
_ => None,
})
.collect()
})
.unwrap_or_default();
assert_eq!(back, all);
}
/// A scatter chart this model makes is written as markers without lines, the same part the
/// shared model writes for its own new scatter chart.
#[test]
fn a_new_scatter_chart_is_written_without_lines() {
let local = wordcraft_doc::chart::ChartSpec::sample(wordcraft_doc::chart::ChartType::Scatter);
assert!(!local.series.is_empty() && local.series.iter().all(|s| s.no_line));
assert_eq!(
crate::chart_xml(&local),
craft_docx::chart_xml(&craft_wordmodel::chart::ChartSpec::sample(craft_wordmodel::chart::ChartType::Scatter)).into_bytes()
);
for kind in wordcraft_doc::chart::ChartType::ALL {
let local = wordcraft_doc::chart::ChartSpec::sample(kind);
let shared: craft_wordmodel::chart::ChartSpec = convert_ref(&local).expect("convert");
assert_eq!(shared, craft_wordmodel::chart::ChartSpec::sample(shared.kind), "{kind:?}");
}
}
#[test]
fn bridges_nested_stories_and_moves_media_both_directions() {
let mut source = craft_wordmodel::Document::new();
let long_text = "x".repeat(1 << 16);
let mut body_para = craft_wordmodel::para::Paragraph::with_text(&long_text, Default::default());
body_para.objects.push(craft_wordmodel::para::InlineObject::Group {
w: 32.0,
h: 24.0,
float: Default::default(),
ch_w: 64.0,
ch_h: 48.0,
children: vec![craft_wordmodel::para::GroupChild {
x: 4.0,
y: 6.0,
obj: craft_wordmodel::para::InlineObject::Field {
instr: "PAGE".into(),
result: "7".into(),
locked: true,
dirty: false,
code: false,
form: String::new(),
},
}],
canvas: None,
});
let cell = craft_wordmodel::table::Cell::with_text("nested cell");
let table = craft_wordmodel::table::Table {
rows: vec![craft_wordmodel::table::Row { cells: vec![cell], ..Default::default() }],
..Default::default()
};
source.body = vec![Arc::new(craft_wordmodel::Block::Para(body_para)), Arc::new(craft_wordmodel::Block::Table(table))];
source.parts.insert(
12,
craft_wordmodel::Part {
kind: craft_wordmodel::PartKind::TextBox,
blocks: vec![craft_wordmodel::para_block(craft_wordmodel::para::Paragraph::with_text("part story", Default::default()))],
..Default::default()
},
);
source.settings.compat_mode = 11;
let image = Arc::new(vec![0x5a; 1 << 16]);
source.media.insert("image1.png".into(), image.clone());
let doc = from_shared_model(source).expect("from_shared_model");
assert_eq!(doc.body.len(), 2);
assert_eq!(doc.body[0].as_para().map(|p| p.text.as_str()), Some(long_text.as_str()));
assert!(Arc::ptr_eq(doc.media.get("image1.png").expect("media"), &image));
let back = to_shared_model(&doc).expect("to_shared_model");
assert_eq!(back.body.len(), 2);
assert_eq!(back.body[0].as_para().map(|p| p.text.as_str()), Some(long_text.as_str()));
assert!(Arc::ptr_eq(back.media.get("image1.png").expect("media"), &image));
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.