fast_xlsx 0.4.0 → 0.6.0

data/ext/fast_xlsx/src/lib.rs

@@ -13,7 +13,7 @@ use rust_xlsxwriter::{
     ConditionalFormatCell, ConditionalFormatCellRule, ConditionalFormatDataBar,
     ConditionalFormatFormula, ConditionalFormatText, ConditionalFormatTextRule,
     ConditionalFormatValue, DataValidation, DataValidationRule, FormatAlign, FormatBorder,
-    FormatScript, FormatUnderline, IntoDataValidationValue, IntoExcelData, XlsxError,
+    FormatScript, FormatUnderline, IgnoreError, IntoDataValidationValue, IntoExcelData, XlsxError,
 };
 
 use rust_xlsxwriter::{
@@ -34,9 +34,52 @@ static FORMULA: Lazy<RClass> = Lazy::new(|ruby| fast_xlsx_const(ruby, "Formula")
 static URL: Lazy<RClass> = Lazy::new(|ruby| fast_xlsx_const(ruby, "URL"));
 static RICH_STRING: Lazy<RClass> = Lazy::new(|ruby| fast_xlsx_const(ruby, "RichString"));
 
+// A row or column outside the sheet is a RangeError, like a negative one
+// (which fails converting to an unsigned number before reaching the writer).
 fn xerr(e: XlsxError) -> Error {
     let ruby = Ruby::get().unwrap();
-    Error::new(ruby.get_inner(&ERROR), e.to_string())
+    let class = match e {
+        XlsxError::RowColumnLimitError => ruby.exception_range_error(),
+        // Values that aren't allowed, like a reversed range.
+        XlsxError::RowColumnOrderError | XlsxError::MergeRangeSingleCell => {
+            ruby.exception_arg_error()
+        }
+        _ => ruby.get_inner(&ERROR),
+    };
+    Error::new(class, e.to_string())
+}
+
+// Excel's limits that rust_xlsxwriter doesn't check: a negative width or
+// height hides the column or row, a larger one is capped or invalid.
+// A size that must be a finite number above 0 (NaN or a negative one would
+// be written into the file as is).
+fn check_positive(ruby: &Ruby, what: &str, size: f64) -> Result<f64, Error> {
+    if size.is_finite() && size > 0.0 {
+        return Ok(size);
+    }
+    Err(Error::new(
+        ruby.exception_arg_error(),
+        format!("invalid {what} {size}: use a number above 0"),
+    ))
+}
+
+// A range of rows is checked before any row changes, so it is all or nothing.
+fn check_last_row(last: u32) -> Result<(), Error> {
+    if last < MAX_ROWS {
+        Ok(())
+    } else {
+        Err(xerr(XlsxError::RowColumnLimitError))
+    }
+}
+
+fn check_size(ruby: &Ruby, what: &str, size: f64, max: f64) -> Result<(), Error> {
+    if (0.0..=max).contains(&size) {
+        return Ok(());
+    }
+    Err(Error::new(
+        ruby.exception_arg_error(),
+        format!("invalid {what} {size}: use 0..{max}"),
+    ))
 }
 
 type Shared = Arc<Mutex<rust_xlsxwriter::Workbook>>;
@@ -113,14 +156,20 @@ struct Worksheet {
     table_formats: RefCell<Vec<TableColumnFormat>>,
     // Merged ranges as (first_row, first_col, last_row, last_col).
     merges: RefCell<Vec<(u32, u16, u32, u16)>>,
-    // Column ranges given a format with column_format.
-    formatted_columns: RefCell<Vec<(u16, u16)>>,
+    // Formats given with column_format: (first, last, style).
+    formatted_columns: RefCell<Vec<(u16, u16, Arc<Style>)>>,
+    // Formats given with row_format: (first, last, style).
+    formatted_rows: RefCell<Vec<(u32, u32, Arc<Style>)>>,
+    // Whether a row got options (format, hidden, outline level):
+    // rust_xlsxwriter copies the default row height into a row then, so
+    // default_row_height must come first.
+    row_options_set: Cell<bool>,
 }
 
 struct TableColumnFormat {
     rows: std::ops::RangeInclusive<u32>,
     col: u16,
-    format: Arc<rust_xlsxwriter::Format>,
+    format: Arc<Style>,
 }
 
 impl Workbook {
@@ -183,6 +232,8 @@ impl Workbook {
             table_formats: RefCell::new(Vec::new()),
             merges: RefCell::new(Vec::new()),
             formatted_columns: RefCell::new(Vec::new()),
+            formatted_rows: RefCell::new(Vec::new()),
+            row_options_set: Cell::new(false),
         })
     }
 
@@ -307,7 +358,7 @@ enum CellValue {
     Formula(String),
     Url(String, Option<String>),
     // RichString segments; None means the default font.
-    Rich(Vec<(Option<Arc<rust_xlsxwriter::Format>>, String)>),
+    Rich(Vec<(Option<Arc<Style>>, String)>),
 }
 
 impl CellValue {
@@ -348,16 +399,10 @@ impl CellValue {
         Ok(value)
     }
 
-    // The format for a value written without one: without a number format
-    // Excel shows a date as its serial number.
-    fn default_format(&self) -> Option<&'static rust_xlsxwriter::Format> {
-        static DATE: LazyLock<rust_xlsxwriter::Format> =
-            LazyLock::new(|| rust_xlsxwriter::Format::new().set_num_format("yyyy-mm-dd"));
-        static DATE_TIME: LazyLock<rust_xlsxwriter::Format> =
-            LazyLock::new(|| rust_xlsxwriter::Format::new().set_num_format("yyyy-mm-dd hh:mm:ss"));
+    // Some(has a time of day) for date cells.
+    fn date_kind(&self) -> Option<bool> {
         match self {
-            CellValue::Date(_, false) => Some(&DATE),
-            CellValue::Date(_, true) => Some(&DATE_TIME),
+            CellValue::Date(_, time) => Some(*time),
             _ => None,
         }
     }
@@ -390,7 +435,11 @@ impl CellValue {
         format: Option<&rust_xlsxwriter::Format>,
     ) -> Result<(), Error> {
         match self {
-            CellValue::Empty => Ok(()),
+            // nil writes nothing, unless it has a format (e.g. a border).
+            CellValue::Empty => match format {
+                Some(f) => ws.write_blank(row, col, f).map(|_| ()).map_err(xerr),
+                None => Ok(()),
+            },
             CellValue::Text(s) => emit(ws, row, col, s.as_str(), format),
             CellValue::Number(n) | CellValue::Date(n, _) => emit(ws, row, col, *n, format),
             CellValue::Bool(b) => emit(ws, row, col, *b, format),
@@ -412,7 +461,7 @@ impl CellValue {
                 let default = rust_xlsxwriter::Format::default();
                 let rich: Vec<(&rust_xlsxwriter::Format, &str)> = parts
                     .iter()
-                    .map(|(f, text)| (f.as_deref().unwrap_or(&default), text.as_str()))
+                    .map(|(f, text)| (f.as_deref().map_or(&default, |s| &s.format), text.as_str()))
                     .collect();
                 match format {
                     Some(f) => ws.write_rich_string_with_format(row, col, &rich, f),
@@ -583,7 +632,7 @@ fn check_header_footer(ruby: &Ruby, what: &str, text: &str) -> Result<(), Error>
     let len = expanded.chars().count();
     if len > 255 {
         return Err(Error::new(
-            ruby.exception_arg_error(),
+            ruby.get_inner(&ERROR),
             format!("{what} is {len} characters; Excel allows 255"),
         ));
     }
@@ -714,10 +763,7 @@ const TABLE_TOTALS: &[(&str, TableFunction)] = &[
 
 // A table column: a header String, or { header:, total:, total_label:, format: }.
 // Also returns a copy of the column's format, if any, for later writes.
-fn table_column(
-    ruby: &Ruby,
-    v: Value,
-) -> Result<(TableColumn, Option<Arc<rust_xlsxwriter::Format>>), Error> {
+fn table_column(ruby: &Ruby, v: Value) -> Result<(TableColumn, Option<Arc<Style>>), Error> {
     let Some(spec) = RHash::from_value(v) else {
         return Ok((TableColumn::new().set_header(String::try_convert(v)?), None));
     };
@@ -737,7 +783,7 @@ fn table_column(
     }
     let format = opt::<&Format>(ruby, spec, "format")?.map(|f| f.0.clone());
     if let Some(f) = &format {
-        column = column.set_format(&**f);
+        column = column.set_format(&f.format);
     }
     Ok((column, format))
 }
@@ -761,6 +807,29 @@ const PROTECTION_ALLOW: &[(&str, ProtectionFlag)] = &[
     ("edit_objects", |o| &mut o.edit_objects),
 ];
 
+// Not IgnoreError::TwoDigitTextYear: rust_xlsxwriter 0.99 writes it as
+// "TwoDigitTextYear", not the schema's "twoDigitTextYear", which Excel would
+// flag as damaged content. Add it once that is fixed upstream.
+const IGNORE_ERRORS: &[(&str, IgnoreError)] = &[
+    ("number_stored_as_text", IgnoreError::NumberStoredAsText),
+    ("formula_error", IgnoreError::FormulaError),
+    ("formula_differs", IgnoreError::FormulaDiffers),
+    (
+        "formula_refers_to_empty_cells",
+        IgnoreError::FormulaRefersToEmptyCells,
+    ),
+    ("formula_omits_cells", IgnoreError::FormulaOmitsCells),
+    ("data_validation_error", IgnoreError::DataValidationError),
+    (
+        "unlocked_cells_with_formula",
+        IgnoreError::UnlockedCellsWithFormula,
+    ),
+    (
+        "inconsistent_column_formula",
+        IgnoreError::InconsistentColumnFormula,
+    ),
+];
+
 // Excel's paper size codes; page_setup also takes the number itself.
 const PAPER_SIZES: &[(&str, u8)] = &[
     ("letter", 1),
@@ -782,11 +851,52 @@ const BORDERS: &[(&str, FormatBorder)] = &[
 ];
 
 #[magnus::wrap(class = "FastXlsx::Format", free_immediately)]
-struct Format(Arc<rust_xlsxwriter::Format>);
+struct Format(Arc<Style>);
+
+// A Format as written: the format itself, and for one without a num_format,
+// copies with the default date formats added, used for date cells (Excel
+// shows a date with no number format as its serial number).
+struct Style {
+    format: rust_xlsxwriter::Format,
+    date: Option<rust_xlsxwriter::Format>,
+    date_time: Option<rust_xlsxwriter::Format>,
+}
+
+const DATE_FORMAT: &str = "yyyy-mm-dd";
+const DATE_TIME_FORMAT: &str = "yyyy-mm-dd hh:mm:ss";
+
+impl Style {
+    fn new(format: rust_xlsxwriter::Format, has_num_format: bool) -> Self {
+        let with =
+            |num_format: &str| (!has_num_format).then(|| format.clone().set_num_format(num_format));
+        Style {
+            date: with(DATE_FORMAT),
+            date_time: with(DATE_TIME_FORMAT),
+            format,
+        }
+    }
+
+    // The date variant for a date cell (`time`: it has a time of day), if
+    // this format has no num_format of its own.
+    fn for_date(&self, time: bool) -> Option<&rust_xlsxwriter::Format> {
+        if time {
+            self.date_time.as_ref()
+        } else {
+            self.date.as_ref()
+        }
+    }
+
+    // What a value is written with: `date` is Some(has time) for date cells.
+    fn pick(&self, date: Option<bool>) -> &rust_xlsxwriter::Format {
+        date.and_then(|time| self.for_date(time))
+            .unwrap_or(&self.format)
+    }
+}
 
 impl Format {
     fn new(ruby: &Ruby, options: RHash) -> Result<Self, Error> {
         let mut f = rust_xlsxwriter::Format::new();
+        let mut has_num_format = false;
         options.foreach(|key: Symbol, value: Value| {
             let taken = std::mem::take(&mut f);
             f = match &*key.name()? {
@@ -834,8 +944,15 @@ impl Format {
                 "locked" => taken.set_unlocked(),
                 "hidden" if value.to_bool() => taken.set_hidden(),
                 "border_color" => taken.set_border_color(color(ruby, value)?),
-                "num_format" => taken.set_num_format(String::try_convert(value)?),
-                "font_size" => taken.set_font_size(f64::try_convert(value)?),
+                "num_format" => {
+                    has_num_format = true;
+                    taken.set_num_format(String::try_convert(value)?)
+                }
+                "font_size" => taken.set_font_size(check_positive(
+                    ruby,
+                    "font_size",
+                    f64::try_convert(value)?,
+                )?),
                 "font_name" => taken.set_font_name(String::try_convert(value)?),
                 "font_color" => taken.set_font_color(color(ruby, value)?),
                 "bg_color" => taken.set_background_color(color(ruby, value)?),
@@ -876,7 +993,7 @@ impl Format {
             };
             Ok(ForEach::Continue)
         })?;
-        Ok(Format(Arc::new(f)))
+        Ok(Format(Arc::new(Style::new(f, has_num_format))))
     }
 }
 
@@ -899,7 +1016,7 @@ fn each_entry(
 
 // A row's format: one Format (or nil) for every cell, or an Array with one per cell.
 enum RowFormat {
-    Same(Option<Arc<rust_xlsxwriter::Format>>),
+    Same(Option<Arc<Style>>),
     PerCell(RArray),
 }
 
@@ -913,7 +1030,7 @@ impl RowFormat {
         }
     }
 
-    fn at(&self, col: usize) -> Result<Option<Arc<rust_xlsxwriter::Format>>, Error> {
+    fn at(&self, col: usize) -> Result<Option<Arc<Style>>, Error> {
         match self {
             RowFormat::Same(f) => Ok(f.clone()),
             RowFormat::PerCell(formats) => Ok(Option::<&Format>::try_convert(
@@ -955,42 +1072,52 @@ impl Worksheet {
         f(wb.worksheet_from_index(self.index).map_err(xerr)?)
     }
 
-    // The format to write a cell with: its own, else its table column's.
-    fn cell_format<'a>(
+    // The format a value is written with: its own, else its table column's.
+    // A date cell takes that format's date variant (when it has no
+    // num_format); with neither, its row_format's, else its column_format's
+    // date variant (rust_xlsxwriter's order), else the default date format.
+    // Other cells without one get None, so rust_xlsxwriter applies any row or
+    // column format itself.
+    fn format_for<'a>(
         tables: &'a [TableColumnFormat],
+        rows: &'a [(u32, u32, Arc<Style>)],
+        columns: &'a [(u16, u16, Arc<Style>)],
         row: u32,
         col: u16,
-        own: Option<&'a rust_xlsxwriter::Format>,
+        own: Option<&'a Style>,
+        value: &CellValue,
     ) -> Option<&'a rust_xlsxwriter::Format> {
-        own.or_else(|| {
+        static DEFAULTS: LazyLock<Style> =
+            LazyLock::new(|| Style::new(rust_xlsxwriter::Format::new(), false));
+        let date = value.date_kind();
+        let style = own.or_else(|| {
             tables
                 .iter()
                 .rev()
                 .find(|t| t.col == col && t.rows.contains(&row))
                 .map(|t| &*t.format)
-        })
-    }
-
-    // The format a value is written with: its own, else its table column's,
-    // else its type's default (dates) unless column_format covers the column,
-    // whose format rust_xlsxwriter applies to cells written without one.
-    fn format_for<'a>(
-        &self,
-        tables: &'a [TableColumnFormat],
-        row: u32,
-        col: u16,
-        own: Option<&'a rust_xlsxwriter::Format>,
-        value: &CellValue,
-    ) -> Option<&'a rust_xlsxwriter::Format> {
-        Self::cell_format(tables, row, col, own).or_else(|| {
-            value.default_format().filter(|_| {
-                !self
-                    .formatted_columns
-                    .borrow()
-                    .iter()
-                    .any(|&(first, last)| (first..=last).contains(&col))
-            })
-        })
+        });
+        if let Some(style) = style {
+            return Some(style.pick(date));
+        }
+        let time = date?;
+        let row_style = rows
+            .iter()
+            .rev()
+            .find(|(first, last, _)| (*first..=*last).contains(&row))
+            .map(|(_, _, style)| style);
+        let column_style = || {
+            columns
+                .iter()
+                .rev()
+                .find(|(first, last, _)| (*first..=*last).contains(&col))
+                .map(|(_, _, style)| style)
+        };
+        match row_style.or_else(column_style) {
+            // None when it has a num_format: rust_xlsxwriter applies it.
+            Some(style) => style.for_date(time),
+            None => DEFAULTS.for_date(time),
+        }
     }
 
     fn write_row(
@@ -1006,7 +1133,7 @@ impl Worksheet {
         each_entry(cells, |i, v| {
             if i >= MAX_COLS {
                 return Err(Error::new(
-                    ruby.exception_arg_error(),
+                    ruby.exception_range_error(),
                     format!("too many columns: Excel allows {MAX_COLS}"),
                 ));
             }
@@ -1015,11 +1142,21 @@ impl Worksheet {
             Ok(())
         })?;
         let tables = self.table_formats.borrow();
+        let rows = self.formatted_rows.borrow();
+        let columns = self.formatted_columns.borrow();
         self.with_ws(|ws| {
             // Values were checked when converted, so only a bad row number
             // fails here, and it fails on the first cell.
             for (col, value, format) in &values {
-                let format = self.format_for(&tables, row, *col, format.as_deref(), value);
+                let format = Self::format_for(
+                    &tables,
+                    &rows,
+                    &columns,
+                    row,
+                    *col,
+                    format.as_deref(),
+                    value,
+                );
                 value.write(ws, row, *col, format)?;
             }
             Ok(())
@@ -1063,12 +1200,22 @@ impl Worksheet {
         rb_self.check_not_flushed(ruby, row)?;
         let value = CellValue::from_ruby(ruby, v)?;
         let tables = rb_self.table_formats.borrow();
+        let rows = rb_self.formatted_rows.borrow();
+        let columns = rb_self.formatted_columns.borrow();
         rb_self.with_ws(|ws| {
             value.write(
                 ws,
                 row,
                 col,
-                rb_self.format_for(&tables, row, col, format.map(|f| &*f.0), &value),
+                Self::format_for(
+                    &tables,
+                    &rows,
+                    &columns,
+                    row,
+                    col,
+                    format.map(|f| &*f.0),
+                    &value,
+                ),
             )
         })?;
         rb_self.advance(row);
@@ -1100,21 +1247,167 @@ impl Worksheet {
         Ok(rb_self)
     }
 
-    fn set_column_width(&self, first: u16, last: u16, width: f64) -> Result<(), Error> {
-        self.with_ws(|ws| {
+    fn set_column_width(
+        ruby: &Ruby,
+        rb_self: &Self,
+        first: u16,
+        last: u16,
+        width: f64,
+    ) -> Result<(), Error> {
+        check_size(ruby, "column width", width, 255.0)?;
+        rb_self.with_ws(|ws| {
             ws.set_column_range_width(first, last, width)
                 .map(|_| ())
                 .map_err(xerr)
         })
     }
 
+    // Row options are written with the row, so rows on disk ignore them.
+    fn hide_rows(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        first: u32,
+        last: u32,
+    ) -> Result<Obj<Self>, Error> {
+        rb_self.check_not_flushed(ruby, first)?;
+        check_last_row(last)?;
+        rb_self.with_ws(|ws| {
+            for row in first..=last {
+                ws.set_row_hidden(row).map_err(xerr)?;
+            }
+            Ok(())
+        })?;
+        rb_self.row_options_set.set(true);
+        Ok(rb_self)
+    }
+
+    fn selection(
+        rb_self: Obj<Self>,
+        fr: u32,
+        fc: u16,
+        lr: u32,
+        lc: u16,
+    ) -> Result<Obj<Self>, Error> {
+        rb_self.with_ws(|ws| ws.set_selection(fr, fc, lr, lc).map(|_| ()).map_err(xerr))?;
+        Ok(rb_self)
+    }
+
+    fn top_left_cell(rb_self: Obj<Self>, row: u32, col: u16) -> Result<Obj<Self>, Error> {
+        rb_self.with_ws(|ws| ws.set_top_left_cell(row, col).map(|_| ()).map_err(xerr))?;
+        Ok(rb_self)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn ignore_error(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        fr: u32,
+        fc: u16,
+        lr: u32,
+        lc: u16,
+        kind: Value,
+    ) -> Result<Obj<Self>, Error> {
+        let error = choice(ruby, "error to ignore", kind, IGNORE_ERRORS)?;
+        rb_self.with_ws(|ws| {
+            ws.ignore_error_range(fr, fc, lr, lc, error)
+                .map(|_| ())
+                .map_err(xerr)
+        })?;
+        Ok(rb_self)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn unprotect_range(
+        rb_self: Obj<Self>,
+        fr: u32,
+        fc: u16,
+        lr: u32,
+        lc: u16,
+        name: Option<String>,
+        password: Option<String>,
+    ) -> Result<Obj<Self>, Error> {
+        rb_self.with_ws(|ws| {
+            ws.unprotect_range_with_options(
+                fr,
+                fc,
+                lr,
+                lc,
+                name.as_deref().unwrap_or(""),
+                password.as_deref().unwrap_or(""),
+            )
+            .map(|_| ())
+            .map_err(xerr)
+        })?;
+        Ok(rb_self)
+    }
+
+    fn hide_columns(rb_self: Obj<Self>, first: u16, last: u16) -> Result<Obj<Self>, Error> {
+        rb_self.with_ws(|ws| {
+            ws.set_column_range_hidden(first, last)
+                .map(|_| ())
+                .map_err(xerr)
+        })?;
+        Ok(rb_self)
+    }
+
+    fn set_row_format(
+        ruby: &Ruby,
+        rb_self: &Self,
+        first: u32,
+        last: u32,
+        format: &Format,
+    ) -> Result<(), Error> {
+        rb_self.check_not_flushed(ruby, first)?;
+        check_last_row(last)?;
+        rb_self.with_ws(|ws| {
+            for row in first..=last {
+                ws.set_row_format(row, &format.0.format).map_err(xerr)?;
+            }
+            Ok(())
+        })?;
+        rb_self.row_options_set.set(true);
+        rb_self
+            .formatted_rows
+            .borrow_mut()
+            .push((first, last, format.0.clone()));
+        Ok(())
+    }
+
+    fn default_row_height(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        height: f64,
+    ) -> Result<Obj<Self>, Error> {
+        // rust_xlsxwriter ignores 0.
+        if height == 0.0 {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "invalid default row height 0: use a number above 0",
+            ));
+        }
+        check_size(ruby, "row height", height, 409.0)?;
+        if rb_self.row_options_set.get() {
+            return Err(Error::new(
+                ruby.get_inner(&ERROR),
+                "call default_row_height before row_format, hide_rows, group_rows or row_height(row, 0): rows given those keep the earlier default",
+            ));
+        }
+        rb_self.with_ws(|ws| {
+            ws.set_default_row_height(height);
+            Ok(())
+        })?;
+        Ok(rb_self)
+    }
+
     fn set_column_format(&self, first: u16, last: u16, format: &Format) -> Result<(), Error> {
         self.with_ws(|ws| {
-            ws.set_column_range_format(first, last, &format.0)
+            ws.set_column_range_format(first, last, &format.0.format)
                 .map(|_| ())
                 .map_err(xerr)
         })?;
-        self.formatted_columns.borrow_mut().push((first, last));
+        self.formatted_columns
+            .borrow_mut()
+            .push((first, last, format.0.clone()));
         Ok(())
     }
 
@@ -1146,8 +1439,18 @@ impl Worksheet {
         Ok(rb_self)
     }
 
-    fn set_row_height(rb_self: Obj<Self>, row: u32, height: f64) -> Result<Obj<Self>, Error> {
+    fn set_row_height(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        row: u32,
+        height: f64,
+    ) -> Result<Obj<Self>, Error> {
+        check_size(ruby, "row height", height, 409.0)?;
         rb_self.with_ws(|ws| ws.set_row_height(row, height).map(|_| ()).map_err(xerr))?;
+        // A height is kept as given; only 0 (hiding the row) copies the default.
+        if height == 0.0 {
+            rb_self.row_options_set.set(true);
+        }
         Ok(rb_self)
     }
 
@@ -1167,17 +1470,32 @@ impl Worksheet {
         })
     }
 
-    // Inches; a negative value keeps the current margin.
+    // Inches; None keeps the current margin.
+    #[allow(clippy::too_many_arguments)]
     fn set_margins(
-        &self,
-        left: f64,
-        right: f64,
-        top: f64,
-        bottom: f64,
-        header: f64,
-        footer: f64,
+        ruby: &Ruby,
+        rb_self: &Self,
+        left: Option<f64>,
+        right: Option<f64>,
+        top: Option<f64>,
+        bottom: Option<f64>,
+        header: Option<f64>,
+        footer: Option<f64>,
     ) -> Result<(), Error> {
-        self.with_ws(|ws| {
+        // rust_xlsxwriter keeps a margin given as a negative number.
+        let inches = |margin: Option<f64>| -> Result<f64, Error> {
+            match margin {
+                None => Ok(-1.0),
+                Some(m) if m.is_finite() && m >= 0.0 => Ok(m),
+                Some(m) => Err(Error::new(
+                    ruby.exception_arg_error(),
+                    format!("invalid margin {m}: use 0 or more inches"),
+                )),
+            }
+        };
+        let (left, right, top) = (inches(left)?, inches(right)?, inches(top)?);
+        let (bottom, header, footer) = (inches(bottom)?, inches(header)?, inches(footer)?);
+        rb_self.with_ws(|ws| {
             ws.set_margins(left, right, top, bottom, header, footer);
             Ok(())
         })
@@ -1238,8 +1556,17 @@ impl Worksheet {
         }
         let value = CellValue::from_ruby(ruby, v)?;
         let tables = rb_self.table_formats.borrow();
-        let format =
-            rb_self.format_for(&tables, first_row, first_col, format.map(|f| &*f.0), &value);
+        let rows = rb_self.formatted_rows.borrow();
+        let columns = rb_self.formatted_columns.borrow();
+        let format = Self::format_for(
+            &tables,
+            &rows,
+            &columns,
+            first_row,
+            first_col,
+            format.map(|f| &*f.0),
+            &value,
+        );
         let default = rust_xlsxwriter::Format::new();
         rb_self.with_ws(|ws| {
             // The value was checked when converted, so once the range is
@@ -1306,7 +1633,7 @@ impl Worksheet {
                 let mut cf =
                     ConditionalFormatCell::new().set_rule(cell_rule(ruby, criteria, value)?);
                 if let Some(f) = format {
-                    cf = cf.set_format(&*f.0);
+                    cf = cf.set_format(&f.0.format);
                 }
                 rule(range, cf)
             }
@@ -1330,7 +1657,7 @@ impl Worksheet {
                 };
                 let mut cf = ConditionalFormatText::new().set_rule(text_rule);
                 if let Some(f) = format {
-                    cf = cf.set_format(&*f.0);
+                    cf = cf.set_format(&f.0.format);
                 }
                 rule(range, cf)
             }
@@ -1338,7 +1665,7 @@ impl Worksheet {
                 let mut cf =
                     ConditionalFormatFormula::new().set_rule(String::try_convert(value)?.as_str());
                 if let Some(f) = format {
-                    cf = cf.set_format(&*f.0);
+                    cf = cf.set_format(&f.0.format);
                 }
                 rule(range, cf)
             }
@@ -1469,9 +1796,14 @@ impl Worksheet {
         )?;
         // SAFETY: the bytes are copied into the Image before any Ruby code runs.
         let mut image = Image::new_from_buffer(unsafe { bytes.as_slice() }).map_err(xerr)?;
-        let width = opt::<f64>(ruby, options, "width")?;
-        let height = opt::<f64>(ruby, options, "height")?;
-        if let Some(scale) = opt::<f64>(ruby, options, "scale")? {
+        let positive = |name: &str| -> Result<Option<f64>, Error> {
+            opt::<f64>(ruby, options, name)?
+                .map(|v| check_positive(ruby, name, v))
+                .transpose()
+        };
+        let width = positive("width")?;
+        let height = positive("height")?;
+        if let Some(scale) = positive("scale")? {
             if width.is_some() || height.is_some() {
                 return Err(Error::new(
                     ruby.exception_arg_error(),
@@ -1680,16 +2012,7 @@ impl Worksheet {
         Ok(rb_self)
     }
 
-    fn zoom(ruby: &Ruby, rb_self: Obj<Self>, percent: Value) -> Result<Obj<Self>, Error> {
-        // Integers only: converting would quietly truncate 150.9.
-        let percent = Integer::from_value(percent)
-            .ok_or_else(|| {
-                Error::new(
-                    ruby.exception_type_error(),
-                    format!("zoom must be an Integer, got {}", percent.inspect()),
-                )
-            })?
-            .to_i64()?;
+    fn zoom(ruby: &Ruby, rb_self: Obj<Self>, percent: i64) -> Result<Obj<Self>, Error> {
         // rust_xlsxwriter only prints a warning for these.
         if !(10..=400).contains(&percent) {
             return Err(Error::new(
@@ -1813,6 +2136,7 @@ impl Worksheet {
             .map(|_| ())
             .map_err(xerr)
         })?;
+        rb_self.row_options_set.set(true);
         Ok(rb_self)
     }
 
@@ -1903,6 +2227,17 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         "vertical_page_breaks",
         method!(Worksheet::set_vertical_page_breaks, 1),
     )?;
+    ws.define_method("_hide_rows", method!(Worksheet::hide_rows, 2))?;
+    ws.define_method("_hide_columns", method!(Worksheet::hide_columns, 2))?;
+    ws.define_method("_row_format", method!(Worksheet::set_row_format, 3))?;
+    ws.define_method(
+        "default_row_height",
+        method!(Worksheet::default_row_height, 1),
+    )?;
+    ws.define_method("_selection", method!(Worksheet::selection, 4))?;
+    ws.define_method("_top_left_cell", method!(Worksheet::top_left_cell, 2))?;
+    ws.define_method("_ignore_error", method!(Worksheet::ignore_error, 5))?;
+    ws.define_method("_unprotect_range", method!(Worksheet::unprotect_range, 6))?;
     ws.define_method("activate", method!(Worksheet::activate, 0))?;
     ws.define_method("hide", method!(Worksheet::hide, 0))?;
     ws.define_method("zoom", method!(Worksheet::zoom, 1))?;