docxdriver 0.4.3__tar.gz → 0.4.4__tar.gz

{docxdriver-0.4.3 → docxdriver-0.4.4}/Cargo.lock

@@ -416,7 +416,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-cli"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "clap",
  "docxdriver-core",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-core"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "hex",
  "latex2mathml",
@@ -445,7 +445,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-mcp"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "axum",
  "cap-std",
@@ -463,14 +463,14 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-monty-repl"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "docxdriver-core",
 ]
 
 [[package]]
 name = "docxdriver-python"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "docxdriver-core",
  "pyo3",
@@ -480,7 +480,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-wasm"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "docxdriver-core",
  "js-sys",

{docxdriver-0.4.3 → docxdriver-0.4.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/docxdriver-python"]
 
 [workspace.package]
-version = "0.4.3"
+version = "0.4.4"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/jhnoel/docxdriver"

{docxdriver-0.4.3 → docxdriver-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docxdriver
-Version: 0.4.3
+Version: 0.4.4
 Summary: Python SDK for the native Rust DOCX engine
 License-Expression: MIT
 Requires-Python: >=3.10

{docxdriver-0.4.3 → docxdriver-0.4.4}/crates/docxdriver-core/src/api.rs

@@ -564,7 +564,20 @@ pub enum EditOp {
         with: String,
     },
     EditTable { at: String, action: TableEdit },
-    InsertTable { at: ParagraphAddress, position: InsertPosition, rows: u32, columns: u32, #[serde(rename = "as", default)] alias: Option<String> },
+    /// A `rows` × `columns` grid of new cells. `cells` fills them row by
+    /// row with the inline content `insert_paragraph`'s `with` accepts;
+    /// missing trailing rows and cells stay empty. With `as`, cell row N
+    /// column M is the paragraph alias `$<as>_rNcM` for later operations.
+    InsertTable {
+        at: ParagraphAddress,
+        position: InsertPosition,
+        rows: u32,
+        columns: u32,
+        #[serde(default)]
+        cells: Option<Vec<Vec<String>>>,
+        #[serde(rename = "as", default)]
+        alias: Option<String>,
+    },
     FormatTable { at: String, format: TableFormat },
     FormatRow { at: String, format: RowFormat },
     FormatCell { at: String, format: CellFormat },
@@ -1394,9 +1407,31 @@ fn normalize_op(op: &mut EditOp) -> Result<(), String> {
             }
         }
         EditOp::EditTable { at, action } => crate::commands::table_structure::validate(at, action)?,
-        EditOp::InsertTable { rows, columns, alias, .. } => {
+        EditOp::InsertTable { rows, columns, cells, alias, .. } => {
             if *rows == 0 || *columns == 0 || *rows > 100 || *columns > 100 { return Err("insert_table dimensions must be 1..100".into()); }
             if alias.as_ref().is_some_and(|a| !valid_alias(a)) { return Err("invalid alias".into()); }
+            let cells = cells.as_deref().unwrap_or_default();
+            if cells.len() > *rows as usize {
+                let extra = cells.len() - *rows as usize;
+                return Err(format!(
+                    "cells has {} rows but the table has {rows}: remove cells[{rows}..] (row {}{})",
+                    cells.len(),
+                    *rows + 1,
+                    if extra > 1 { format!(" to row {}", cells.len()) } else { String::new() },
+                ));
+            }
+            for (index, row) in cells.iter().enumerate() {
+                if row.len() > *columns as usize {
+                    let extra = row.len() - *columns as usize;
+                    return Err(format!(
+                        "cells[{index}] (row {}) has {} cells but the table has {columns} columns: remove cells[{index}][{columns}..] (column {}{})",
+                        index + 1,
+                        row.len(),
+                        *columns + 1,
+                        if extra > 1 { format!(" to column {}", row.len()) } else { String::new() },
+                    ));
+                }
+            }
         }
         EditOp::FormatTable { at, format } => crate::commands::tables::validate_table(at, format)?,
         EditOp::FormatRow { at, format } => crate::commands::tables::validate_row(at, format)?,
@@ -2002,6 +2037,37 @@ fn fold_typed(
             if matches!(op, EditOp::InsertTable { .. } | EditOp::EditTable { .. }) {
                 aliases.insert(alias.clone(), Value::String(format!("${alias}")));
             }
+            if let Some(rows) = outcome.result.as_ref().and_then(|r| r.get("cells")).and_then(Value::as_array) {
+                let cells = rows.iter().enumerate().flat_map(|(r, row)| {
+                    row.as_array().into_iter().flatten().enumerate().map(move |(c, id)| (format!("{alias}_r{}c{}", r + 1, c + 1), id.clone()))
+                });
+                for (name, id) in cells {
+                    if aliases.contains_key(&name) {
+                        attach_affected(&mut state, &mut reports, &affected_ids);
+                        let report = PlanReport {
+                            completed: index,
+                            stopped_at: Some(index),
+                            ops: reports,
+                            repaired_ids: repaired_ids.clone(),
+                            allocated_ids: allocated_ids.clone(),
+                            aliases: aliases.clone().into_iter().collect(),
+                        };
+                        return (
+                            report.clone(),
+                            None,
+                            Some((
+                                diag(
+                                    "duplicate_alias",
+                                    format!("cell alias {name:?} of table alias {alias:?} is already defined"),
+                                    Some(format!("ops[{index}].as")),
+                                ),
+                                report,
+                            )),
+                        );
+                    }
+                    aliases.insert(name, id);
+                }
+            }
             if let Some(id) = outcome
                 .result
                 .as_ref()
@@ -2012,6 +2078,12 @@ fn fold_typed(
                 aliases.insert(alias.clone(), id);
             }
         }
+        if let EditOp::InsertTable { .. } = op {
+            let rows = outcome.result.as_ref().and_then(|r| r.get("cells")).and_then(Value::as_array);
+            for id in rows.into_iter().flatten().filter_map(Value::as_array).flatten() {
+                allocated_ids.push(id.as_str().unwrap_or_default().into());
+            }
+        }
     }
     attach_affected(&mut state, &mut reports, &affected_ids);
     let report = PlanReport {

{docxdriver-0.4.3 → docxdriver-0.4.4}/crates/docxdriver-core/src/commands/mod.rs

@@ -328,9 +328,10 @@ fn run_typed_edit_inner(
         EditOp::EditTable { at, action } => {
             mutate(state, |pkg, xml, _source| table_structure::edit(pkg, xml, at, action, tracked))
         }
-        EditOp::InsertTable { at, position, rows, columns, .. } => {
+        EditOp::InsertTable { at, position, rows, columns, cells, .. } => {
             let at = para_id!(at);
-            mutate(state, |pkg, xml, source| table_structure::insert(pkg, xml, source, &at, *position, *rows, *columns, tracked))
+            let cells = cells.as_deref().unwrap_or_default();
+            mutate(state, |pkg, xml, source| table_structure::insert(pkg, xml, source, &at, *position, *rows, *columns, cells, tracked, &plan_seed, index))
         }
         EditOp::FormatTable { at, format } => mutate(state, |pkg, xml, _| tables::format_table(Some(pkg), xml, at, format, tracked, author, ctx)),
         EditOp::FormatRow { at, format } => mutate(state, |_, xml, _| tables::format_row(xml, at, format, tracked, author, ctx)),

{docxdriver-0.4.3 → docxdriver-0.4.4}/crates/docxdriver-core/src/commands/table_structure.rs

@@ -497,7 +497,10 @@ pub fn insert(
     position: InsertPosition,
     row_count: u32,
     column_count: u32,
+    cell_content: &[Vec<String>],
     tracked: bool,
+    plan_seed: &[u8; 32],
+    op_index: usize,
 ) -> Result<(String, Value), Outcome> {
     if tracked {
         return Err(error(
@@ -535,10 +538,12 @@ pub fn insert(
         x.doc.append_child(g, c);
     }
     x.doc.append_child(t, g);
+    let mut cell_paragraphs = Vec::new();
     for _ in 0..row_count {
         let r = x.doc.create_element("w:tr");
         for _ in 0..column_count {
             let c = empty_cell(x);
+            cell_paragraphs.push(x.doc.children(c).next().unwrap());
             x.doc.append_child(r, c);
         }
         x.doc.append_child(t, r);
@@ -547,6 +552,38 @@ pub fn insert(
         InsertPosition::Before => x.doc.insert_before(p, t),
         InsertPosition::After => x.doc.insert_after(p, t),
     };
+    // Every cell paragraph gets a durable id now, so later operations in the
+    // same plan can address the cells (as `$alias_rNcM` or by id).
+    let ids = super::typed::allocate_table_cell_para_ids(
+        x,
+        source,
+        plan_seed,
+        op_index,
+        cell_paragraphs.len(),
+    )
+    .map_err(|message| Outcome::error(message))?;
+    for (paragraph, id) in cell_paragraphs.iter().zip(&ids) {
+        x.doc.set_attribute(*paragraph, "w14:paraId", id);
+    }
+    x.ensure_w14_declared();
+    let mut filled = 0;
+    for (row, contents) in cell_content.iter().enumerate() {
+        for (column, with) in contents.iter().enumerate() {
+            if with.is_empty() {
+                continue;
+            }
+            let paragraph = cell_paragraphs[row * column_count as usize + column];
+            super::typed::fill_paragraph_direct(package, x, paragraph, with).map_err(|mut outcome| {
+                outcome.summary = format!("cells[{row}][{column}]: {}", outcome.summary);
+                outcome
+            })?;
+            filled += 1;
+        }
+    }
+    let cell_ids = ids
+        .chunks(column_count as usize)
+        .map(|row| json!(row))
+        .collect::<Vec<_>>();
     if x.is_w(parent, "tc") && x.doc.children(parent).last() == Some(t) {
         let end = x.doc.create_element("w:p");
         x.doc.append_child(parent, end);
@@ -556,8 +593,16 @@ pub fn insert(
         .position(|n| *n == t)
         .unwrap()
         + 1;
+    let summary = if cell_content.is_empty() {
+        format!("inserted table table:{ordinal}")
+    } else {
+        format!(
+            "inserted table table:{ordinal} with {filled} filled cell{}",
+            if filled == 1 { "" } else { "s" }
+        )
+    };
     Ok((
-        "inserted table".into(),
-        json!({"table":format!("table:{ordinal}"),"tracked":false}),
+        summary,
+        json!({"table":format!("table:{ordinal}"),"tracked":false,"cells":cell_ids,"filled":filled}),
     ))
 }

{docxdriver-0.4.3 → docxdriver-0.4.4}/crates/docxdriver-core/src/commands/typed.rs

@@ -1541,6 +1541,19 @@ fn insert_plain_pieces(
             }
             cursor = xml.doc.next_sibling(node);
         }
+        // A part without hyperlinks may not declare the relationships prefix.
+        if let Some(root) = xml.doc.root_element() {
+            let declared = xml.doc.attributes(root).iter().any(|a| {
+                a.name == "xmlns:r" || (a.name == "r" && a.value.contains("relationships"))
+            });
+            if !declared {
+                xml.doc.set_attribute(
+                    root,
+                    "xmlns:r",
+                    "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+                );
+            }
+        }
         let link = xml.doc.create_element("w:hyperlink");
         xml.doc.set_attribute(link, "r:id", &rid);
         attach_created(xml, paragraph, before, link);
@@ -2546,6 +2559,51 @@ fn allocate_insert_para_id_typed(
     allocator.allocate(&seed).map(format_para_id)
 }
 
+/// Unused `w14:paraId`s for the cell paragraphs of a table inserted by
+/// operation `op_index`, one per cell in row-major order. Cell `n` (from 1)
+/// seeds probe slot `n`; slot 0 is the one `insert_paragraph` uses.
+pub(crate) fn allocate_table_cell_para_ids(
+    xml: &DocxXml,
+    source_hash: Option<[u8; 32]>,
+    plan_seed: &[u8; 32],
+    op_index: usize,
+    count: usize,
+) -> Result<Vec<String>, String> {
+    let mut allocator = ParaIdAllocator::new();
+    for node in xml.all_paragraphs() {
+        if let Some(value) = xml.para_id(node).filter(|v| is_valid_para_id(v)) {
+            allocator.reserve(u32::from_str_radix(value, 16).unwrap_or(0));
+        }
+    }
+    let mut prefix = Vec::with_capacity(96);
+    prefix.extend_from_slice(&source_hash.unwrap_or([0; 32]));
+    prefix.push(b'|');
+    prefix.extend_from_slice(plan_seed);
+    prefix.push(b'|');
+    prefix.extend_from_slice(&(op_index as u64).to_le_bytes());
+    prefix.push(b'|');
+    (1..=count as u64)
+        .map(|slot| {
+            let mut seed = prefix.clone();
+            seed.extend_from_slice(&slot.to_le_bytes());
+            allocator.allocate(&seed).map(format_para_id)
+        })
+        .collect()
+}
+
+/// Fill an empty paragraph with `with`, the inline content `insert_paragraph`
+/// accepts, as direct (untracked) runs.
+pub(crate) fn fill_paragraph_direct(
+    package: &mut Package,
+    xml: &mut DocxXml,
+    paragraph: NodeId,
+    with: &str,
+) -> Result<(), Outcome> {
+    let (pieces, link_href) = parse_with(with)?;
+    insert_plain_pieces(xml, package, paragraph, None, &pieces, link_href.as_deref())
+        .map_err(Outcome::error)
+}
+
 /// `insert_paragraph`: insert one paragraph before or after an existing
 /// paragraph, assigning an unused `w14:paraId` in the same part. With
 /// tracking enabled the engine records both the new content and the new

{docxdriver-0.4.3 → docxdriver-0.4.4/crates/docxdriver-python}/python/docxdriver/plan.py

@@ -319,6 +319,7 @@ class InsertTable:
     position: str
     rows: int
     as_: str | None = None
+    cells: list | None = None
     def to_dict(self):
         value = {"op": "insert_table"}
         if self.at is not None:
@@ -331,6 +332,8 @@ class InsertTable:
             value["rows"] = self.rows
         if self.as_ is not None:
             value["as"] = self.as_
+        if self.cells is not None:
+            value["cells"] = self.cells
         return value
 
 @dataclass

{docxdriver-0.4.3 → docxdriver-0.4.4}/crates/docxdriver-python/tests/test_document.py

@@ -4,7 +4,10 @@ import re
 import unittest
 
 from docxdriver import Document, create
-from docxdriver.plan import BookmarkAdd, BookmarkDelete, BookmarkMove, BookmarkRename, CommentAdd, Plan, ReplaceText
+from docxdriver.plan import (
+    BookmarkAdd, BookmarkDelete, BookmarkMove, BookmarkRename, CommentAdd, InsertTable, Plan, ReplaceParagraph,
+    ReplaceText,
+)
 
 
 def first_paragraph(markup):
@@ -75,6 +78,25 @@ class DocumentTests(unittest.TestCase):
         with self.assertRaisesRegex(ValueError, 'unknown read kind'):
             doc.read(kind='marks')
 
+    def test_insert_table_fills_cells_in_one_plan(self):
+        doc = create(paragraphs=['Team'])
+        at = first_paragraph(doc.markup())
+        review = doc.review(Plan(author='T', change_mode='direct', ops=[
+            InsertTable(at=at, position='after', rows=2, columns=2, as_='t',
+                        cells=[['<b>Name</b>', '<b>Role</b>'], ['Ada']]),
+            ReplaceParagraph(at='$t_r2c2', with_='Analyst'),
+        ]))
+        self.assertEqual(review.report['ops'][0]['summary'], 'inserted table table:1 with 3 filled cells')
+        self.assertEqual(len(review.report['allocated_ids']), 4)
+        self.assertEqual(review.report['aliases']['t_r1c1'], review.report['allocated_ids'][0])
+        markup = doc.commit(review.key).markup()
+        for text in ('<b>Name</b>', '<b>Role</b>', '>Ada<', '>Analyst<'):
+            self.assertIn(text, markup)
+        with self.assertRaisesRegex(ValueError, r'remove cells\[0\]\[2\.\.\]'):
+            doc.review(Plan(author='T', change_mode='direct', ops=[
+                InsertTable(at=at, position='after', rows=1, columns=2, cells=[['a', 'b', 'c']]),
+            ]))
+
     def test_commit_needs_a_reviewed_key(self):
         doc = create(paragraphs=['Alpha'])
         with self.assertRaises(ValueError):

{docxdriver-0.4.3/crates/docxdriver-python → docxdriver-0.4.4}/python/docxdriver/plan.py

@@ -319,6 +319,7 @@ class InsertTable:
     position: str
     rows: int
     as_: str | None = None
+    cells: list | None = None
     def to_dict(self):
         value = {"op": "insert_table"}
         if self.at is not None:
@@ -331,6 +332,8 @@ class InsertTable:
             value["rows"] = self.rows
         if self.as_ is not None:
             value["as"] = self.as_
+        if self.cells is not None:
+            value["cells"] = self.cells
         return value
 
 @dataclass