fast_xlsx 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8326db5fb0c181c2c47af1f6b0d5799aa0bb69ff2d3b63d5286dbd1cd32fa2b8
-  data.tar.gz: 560335ade1b435b9084cb3d48e4e4b20d906140c4d2a6e243751d93d1eb01964
+  metadata.gz: c78ccbcfe82884370ef3e64e4613812a91c521f479495184bd99df1cb7f1d36c
+  data.tar.gz: 86702f59f3c33c490ef3879e0178a7bcc9650fdba612bd1cd17ba24662b0392d
 SHA512:
-  metadata.gz: 360e7a3686eb4705527139fc7c50834046aa4d45d7e3e79e6f913475cb039de2e64119600a8c9a0e1147136be98a6776f8bbe8db267b67533e99c390fdaced4e
-  data.tar.gz: c23307efb6c2c0ceb1faef4336be02512f98cda7bff60b01324e614d82374247187ee1225a04c04a1cf9208d8b4abce3852a943f166f57f53801c743c4df1af3
+  metadata.gz: 629352aa7bf14685eef2d940f78b23e142f66b946b6d8f2eb36db0bd004574aefb2e04fd29fe2fc42e9684ac5d125725cfea5384d7a439b8f5d361411f68149c
+  data.tar.gz: f8755a00230b81f405339f9d123344bf827c3010d80f159c0b5408e2fbcc984d3fd94758fd65e7fa5562d0e8b23825cb0d0b791bf97057db013259afd49c3c96

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-02
+
+### Added
+
+- `Worksheet#selection`, `#top_left_cell` (what is selected and scrolled to when the file opens), `#ignore_error` (turns off Excel's green-triangle warnings in a range) and `#unprotect_range` (a range users can edit on a protected sheet).
+- `Worksheet#hide_rows`, `#hide_columns`, `#row_format` (default format for a row's cells) and `#default_row_height` (call it before `row_format`, `hide_rows` and `group_rows`, which copy the default into their rows; it raises otherwise).
+
+### Fixed
+
+- `nil` written with a format (e.g. a border, or a row format in `append`) writes a blank cell with that format; the format was dropped.
+
 ## [0.5.0] - 2026-10-01
 
 ### Added

data/README.md

@@ -101,6 +101,9 @@ ws.zoom(150)                # 10..400 percent
 ws.tab_color("#C00000")
 ws.hide_gridlines
 ws.activate                 # Excel opens on this sheet (un-hides it if hidden)
+ws.selection("B2:C3")       # the cells selected when it opens
+ws.top_left_cell("A50")     # and the cell scrolled to the top left
+ws.ignore_error("A2:A1000", :number_stored_as_text) # no green triangles (one kind per range; don't overlap ranges)
 other.hide                  # the sheet Excel opens on can't be hidden: activate another one first
 
 ws.page_setup(landscape: true, paper: :a4,  # or :letter, :legal, :tabloid, :a3, :a5, Excel's paper number, 0 = printer default
@@ -130,6 +133,9 @@ Methods that take one cell (`write`, `write_comment`, `insert_image`, `insert_ch
 ```ruby
 ws.freeze_panes(1, 0)                          # keep the first row visible while scrolling
 ws.row_height(0, 30)                       # row 1, height in points
+ws.default_row_height(18)                  # every other row; call it before row_format, hide_rows, group_rows
+ws.row_format(0, header)                   # default for cells in row 1 written without a format
+ws.hide_rows(10..20)                       # also hide_columns(3), an index or a Range
 ws.merge_range(0, 0, 0, 3, "Q3 report", title) # merge A1:D1; the value can be any cell type
 ws.page_breaks([50, 100])                  # print a new page before rows 51 and 101
 ws.vertical_page_breaks([8])               # and before column I
@@ -164,6 +170,7 @@ input = FastXlsx::Format.new(locked: false)
 ws.write(1, 1, 0, input)                                  # B2 stays editable
 ws.protect                                                # lock everything else
 ws.protect(password: "secret", allow: %i[sort use_autofilter]) # or with a password and allowed actions
+ws.unprotect_range("B2:D10", name: "Inputs")               # a range users can still edit (optional password:)
 ```
 
 `allow:` takes `:format_cells`, `:format_columns`, `:format_rows`, `:insert_columns`, `:insert_rows`, `:insert_links`, `:delete_columns`, `:delete_rows`, `:sort`, `:use_autofilter`, `:use_pivot_tables`, `:edit_scenarios`, `:edit_objects`. The password only stops editing in Excel; it does not encrypt the file.
@@ -258,7 +265,7 @@ Values are mapped by type:
 | `FastXlsx::URL.new("https://…")`, `URL.new(url, text: "Title")` | hyperlink (optionally showing other text) |
 | `FastXlsx::RichString.new(["Total: ", bold], "1,234")` | text with a format per segment |
 | `true` / `false` | boolean |
-| `nil` | empty cell |
+| `nil` | empty cell (a blank cell with the format, when one is given) |
 | anything else | `to_s` as string |
 
 `<<` and `concat` append after the last row written to that worksheet. In `:constant` / `:low` memory mode rows are written to disk as you go, so fill each worksheet top to bottom.

data/bench/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    fast_xlsx (0.5.0)
+    fast_xlsx (0.6.0)
       rb_sys (~> 0.9.130)
 
 GEM
@@ -77,7 +77,7 @@ DEPENDENCIES
 CHECKSUMS
   caxlsx (4.5.0) sha256=e3d98d859f148df05d5462086b5079b523f29c1766b569535f1d68629ce743ff
   fast_excel (0.5.0) sha256=59c418bdcf586a6030798d4e3a9f575742badaceaf7bb90f38eee5feb5bdc478
-  fast_xlsx (0.5.0)
+  fast_xlsx (0.6.0)
   ffi (1.17.4-aarch64-linux-gnu) sha256=b208f06f91ffd8f5e1193da3cae3d2ccfc27fc36fba577baf698d26d91c080df
   ffi (1.17.4-aarch64-linux-musl) sha256=9286b7a615f2676245283aef0a0a3b475ae3aae2bb5448baace630bb77b91f39
   ffi (1.17.4-arm-linux-gnu) sha256=d6dbddf7cb77bf955411af5f187a65b8cd378cb003c15c05697f5feee1cb1564

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::{
@@ -63,6 +63,15 @@ fn check_positive(ruby: &Ruby, what: &str, size: f64) -> Result<f64, Error> {
     ))
 }
 
+// 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(());
@@ -149,6 +158,12 @@ struct Worksheet {
     merges: RefCell<Vec<(u32, u16, u32, 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 {
@@ -217,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),
         })
     }
 
@@ -418,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),
@@ -786,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),
@@ -1030,11 +1074,13 @@ impl Worksheet {
 
     // 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 column_format's date variant, or the
-    // default date format when the column has no format. Other cells without
-    // one get None, so rust_xlsxwriter applies any column format itself.
+    // 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,
@@ -1055,13 +1101,21 @@ impl Worksheet {
             return Some(style.pick(date));
         }
         let time = date?;
-        match columns
+        let row_style = rows
             .iter()
             .rev()
-            .find(|(first, last, _)| (*first..=*last).contains(&col))
-        {
+            .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),
+            Some(style) => style.for_date(time),
             None => DEFAULTS.for_date(time),
         }
     }
@@ -1088,13 +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, &columns, 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(())
@@ -1138,13 +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,
-                Self::format_for(&tables, &columns, 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);
@@ -1191,6 +1262,143 @@ impl Worksheet {
         })
     }
 
+    // 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.format)
@@ -1239,6 +1447,10 @@ impl Worksheet {
     ) -> 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)
     }
 
@@ -1344,9 +1556,11 @@ impl Worksheet {
         }
         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();
         let format = Self::format_for(
             &tables,
+            &rows,
             &columns,
             first_row,
             first_col,
@@ -1922,6 +2136,7 @@ impl Worksheet {
             .map(|_| ())
             .map_err(xerr)
         })?;
+        rb_self.row_options_set.set(true);
         Ok(rb_self)
     }
 
@@ -2012,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))?;

data/lib/fast_xlsx/version.rb

@@ -2,5 +2,5 @@
 
 module FastXlsx
   # The gem version.
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/fast_xlsx.rb

@@ -226,6 +226,14 @@ module FastXlsx
   #   @param color [String, Integer] "#RRGGBB" or 0xRRGGBB
   #   @return [self]
   #
+  # @!method default_row_height(height)
+  #   Height of rows not given one with {#row_height}. Call it before
+  #   {#row_format}, {#hide_rows} and {#group_rows}: rows given those keep
+  #   the earlier default.
+  #   @param height [Numeric] points, above 0 and up to 409
+  #   @return [self]
+  #   @raise [FastXlsx::Error] when called after those
+  #
   # @!method hide_gridlines
   #   Hides the gridlines on screen (see {#page_setup} for printing).
   #   @return [self]
@@ -441,6 +449,71 @@ module FastXlsx
       _protect(password, Array(allow))
     end
 
+    # A range users can still edit on a protected sheet ({#protect}),
+    # optionally with its own password. Give each range its own name.
+    # @overload unprotect_range(*range, name: nil, password: nil)
+    #   @param name [String, nil] shown in Excel's "Allow Edit Ranges"
+    # @return [self]
+    def unprotect_range(*range, name: nil, password: nil)
+      _unprotect_range(*CellRange.split(range).first, name, password)
+    end
+
+    # The cells selected when the file opens.
+    # @param range a cell range (see {Worksheet})
+    # @return [self]
+    def selection(*range)
+      _selection(*CellRange.split(range).first)
+    end
+
+    # The cell scrolled to the top left when the file opens.
+    # @param cell (row, col) or "B2"
+    # @return [self]
+    def top_left_cell(*cell)
+      _top_left_cell(*CellRange.cell(cell).first(2))
+    end
+
+    # Turns off one of Excel's warnings (green triangles) in the range, e.g.
+    # for codes stored as text. One kind per range (a rust_xlsxwriter limit);
+    # overlapping ranges are accepted, but Excel then uses only one of them.
+    # @overload ignore_error(*range, error)
+    #   @param error [Symbol] :number_stored_as_text, :formula_error,
+    #     :formula_differs, :formula_refers_to_empty_cells,
+    #     :formula_omits_cells, :data_validation_error,
+    #     :unlocked_cells_with_formula, :inconsistent_column_formula
+    # @return [self]
+    # @raise [FastXlsx::Error] when the range already has one
+    def ignore_error(*args)
+      range, (error, *) = CellRange.split(args, 1..1)
+      _ignore_error(*range, error)
+    end
+
+    # Each row in the range is kept (about 1 KB) until saving.
+    # @param rows [Integer, Range<Integer>]
+    # @return [self]
+    # @raise [FastXlsx::Error] in :constant / :low mode, for rows already on disk
+    def hide_rows(rows)
+      _hide_rows(*CellRange.bounds(rows))
+    end
+
+    # @param columns [Integer, Range<Integer>]
+    # @return [self]
+    def hide_columns(columns)
+      _hide_columns(*CellRange.bounds(columns))
+    end
+
+    # Default format for cells in these rows that are written without one.
+    # Use it or {#column_format} for a cell, not both: where both apply, Excel
+    # may combine them or show the row's. Each row is kept (about 1 KB) until
+    # saving, so style a whole sheet with {#column_format}.
+    # @param rows [Integer, Range<Integer>]
+    # @param format [Format]
+    # @return [self]
+    # @raise [FastXlsx::Error] in :constant / :low mode, for rows already on disk
+    def row_format(rows, format)
+      _row_format(*CellRange.bounds(rows), format)
+      self
+    end
+
     # Default format for cells in these columns that are written without one.
     # @param columns [Integer, Range<Integer>]
     # @param format [Format]

data/sig/fast_xlsx.rbs

@@ -62,6 +62,18 @@ module FastXlsx
     def <<: (Array[cell] row) -> self
     def concat: (Array[Array[cell]] rows) -> self
     def column_width: (Integer | Range[Integer] columns, Numeric width) -> self
+    def hide_rows: (Integer | Range[Integer] rows) -> self
+    def hide_columns: (Integer | Range[Integer] columns) -> self
+    def row_format: (Integer | Range[Integer] rows, Format format) -> self
+    def default_row_height: (Numeric height) -> self
+    def selection: (*cell_range range) -> self
+    def top_left_cell: (Integer row, Integer col) -> self
+                     | (String cell) -> self
+    type ignorable_error = :number_stored_as_text | :formula_error | :formula_differs | :formula_refers_to_empty_cells
+                         | :formula_omits_cells | :data_validation_error | :unlocked_cells_with_formula
+                         | :inconsistent_column_formula
+    def ignore_error: (*cell_range | ignorable_error args) -> self
+    def unprotect_range: (*cell_range range, ?name: String?, ?password: String?) -> self
     def column_format: (Integer | Range[Integer] columns, Format format) -> self
     def autofit: () -> self
     # A cell range: four 0-based numbers, an Excel reference ("A1:D10"), or

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_xlsx
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Zac