ironcalc 0.7.1.5-aarch64-linux → 0.9.0.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5177539e077b9d4196fd325f976d094fa9a20751bcb7cb19e726a2a445c92a54
-  data.tar.gz: 523073235219e2ed26d5b7786f766d98da47bed86c164ed2f21dcf9bdd2c5191
+  metadata.gz: 7b80f81c56f14d749ea6119e371a0258dd38382115be8dc472832eabe0d692ae
+  data.tar.gz: 99ea756ee63c1c109ffecf1d808c6e4f3af5ce1a3b3c2652dd971affbefe1843
 SHA512:
-  metadata.gz: c8f9467254059301c04b07115243b6ac0f18101e3c989ca48fd4e06adaa3acca5a7d5c66ff7ec2082694a5cc065b444b21bd64c42bf4461b669ac3eddb680879
-  data.tar.gz: 5911ee0ec8bc25830549d7318b6579d801b31af321a2fcc61c240af5f295f2c97a542f52693be0d1c00e5bc6ffc8f3388c1be9ee71afb6575541df2e76be7bf6
+  metadata.gz: fd841fbe829ceda5c4ae5ff48a13385e8ae12b78e3bdecc0d02483f141e06ad8c9f98c7b305772ddca9925c6bd22d2f4973a702c6d99c8d18f32c1d08eb86740
+  data.tar.gz: d6687d1ff288c153b46015d00158a5d3d030476ccb9d312ffa144d5a68d3a01517dcb75d6118b4dc9411faab985b6be73c25fe525fc460e74f8608537e4f68bc

data/.yardopts

@@ -3,6 +3,7 @@
 --readme README.md
 --output-dir doc
 --no-private
+--hide-api private
 lib/**/*.rb
 -
 README.md

data/CHANGELOG.md

@@ -1,3 +1,56 @@
+## 0.9.0.0
+
+- update the IronCalc engine to 0.9.0
+
+## 0.8.3.0
+
+- update the IronCalc engine to 0.8.3
+- **breaking**: `fill` styles use a single `color` key; `fg_color` and
+  `bg_color` are gone
+- **breaking**: the default font is now Inter 12, was Calibri 13
+- **breaking**: `UserModel#update_range_style` takes the engine's area as a
+  Hash, `update_range_style({sheet:, row:, column:, width:, height:}, path,
+  value)`, and styles the whole range; it took a single cell before
+- **breaking**: every native method has the engine's name and signature, with
+  `nil` for an optional parameter and Hashes for engine structs. Renamed:
+  - `Model`: `clear_cell_contents(sheet, row, column)` →
+    `range_clear_contents(range)`, `get_cell_content` →
+    `get_localized_cell_content`, `get_cell_style` → `get_style_for_cell`,
+    `set_frozen_rows_count` / `set_frozen_columns_count` → `set_frozen_rows` /
+    `set_frozen_columns`, `rename_sheet(sheet, name)` →
+    `rename_sheet_by_index`; `rename_sheet(old_name, new_name)` renames by name
+  - `UserModel`: `clear_cell_contents(sheet, row, column)` →
+    `range_clear_contents(range)`, `set_column_width(sheet, column, width)` →
+    `set_columns_width(sheet, column_start, column_end, width)`, and likewise
+    `set_rows_height`
+- **breaking**: style Hashes have Symbol keys (`style[:font][:b]`); setters
+  accept Symbol or String keys, but no longer a JSON String
+- **breaking**: `UserModel#set_cell_style` is removed; style a `UserModel` per
+  property with `update_range_style`. It could not write back a style read with
+  `get_cell_style`, and failed part-way through.
+- `set_sheet_color` accepts nil to clear a sheet's color
+- sheet colors read back as nil rather than absent when unset
+- defined names on `Model` and `UserModel`: `defined_names`,
+  `new_defined_name`, `update_defined_name`, `delete_defined_name`,
+  `is_valid_defined_name` (raises with the reason) and `valid_defined_name?`
+- typed cell setters on `Model`: `update_cell_with_text`, `_number`, `_bool`,
+  `_formula`
+- typed cell readers on `Model`: `get_cell_value_by_index`,
+  `get_cell_value_by_ref`, `get_cell_formula`, `is_empty_cell`, `get_all_cells`
+- row and column default styles on `Model`: `get`/`set`/`delete_column_style`,
+  `get`/`set`/`delete_row_style`, plus `copy_cell_style`
+- `range_clear_all` on both APIs, `range_clear_formatting` on `UserModel`
+- `insert_sheet` and `set_sheet_state` on `Model`
+- `pause_evaluation` / `resume_evaluation` on `UserModel`, and `batch` to
+  recalculate once after a block
+- hidden rows and columns: `is_column_hidden` / `is_row_hidden` on both APIs,
+  `set_column_hidden` / `set_row_hidden` on `Model`, `set_columns_hidden` /
+  `set_rows_hidden` on `UserModel`
+- xlsx in memory: `to_xlsx_bytes` on both APIs, `load_from_xlsx_bytes` and
+  `create_user_model_from_xlsx_bytes`
+- fix a memory leak: every constructor leaked its string arguments on each call
+- package only README, CHANGELOG and licenses instead of every `*.md`
+
 ## 0.7.1.5
 
 - link to changelog and documentation in gemspec

data/README.md

@@ -39,24 +39,166 @@ um.get_formatted_cell_value(0, 1, 1)    # => "3"
 diffs = um.flush_send_queue             # binary diff to send to peers
 ```
 
-Coordinates: `sheet` is a 0-based index; `row` and `column` are 1-based. Styles
-are exchanged as plain Ruby hashes via `get_cell_style` / `set_cell_style`.
+Coordinates: `sheet` is a 0-based index; `row` and `column` are 1-based. Method
+names and signatures are the engine's own. Engine structs, such as styles and
+cell ranges, are plain Ruby Hashes keyed by their field names.
 
-### Top-level methods
+### API overview
 
-`create`, `load_from_xlsx`, `load_from_icalc`, `load_from_bytes`,
-`create_user_model`, `create_user_model_from_xlsx`,
-`create_user_model_from_icalc`, `create_user_model_from_bytes`.
+The [API reference](https://jvdp.github.io/IronCalc-Ruby/) documents every method; it shows the latest
+release, and [older versions](https://jvdp.github.io/IronCalc-Ruby/versions.html) are kept too.
+
+- [`IronCalc`](https://jvdp.github.io/IronCalc-Ruby/IronCalc.html) — module functions: the constructors (see
+  [Loading and saving](#loading-and-saving)) and utilities for cell references,
+  such as [`number_to_column`](https://jvdp.github.io/IronCalc-Ruby/IronCalc.html#number_to_column-class_method)
+  and [`parse_reference_a1`](https://jvdp.github.io/IronCalc-Ruby/IronCalc.html#parse_reference_a1-class_method).
+- [`IronCalc::UserModel`](https://jvdp.github.io/IronCalc-Ruby/IronCalc/UserModel.html) — the recommended API.
+  It recalculates after every change, supports `undo` / `redo`, and records
+  diffs for collaboration
+  ([`flush_send_queue`](https://jvdp.github.io/IronCalc-Ruby/IronCalc/UserModel.html#flush_send_queue-instance_method)).
+  Styles are set per property with
+  [`update_range_style`](https://jvdp.github.io/IronCalc-Ruby/IronCalc/UserModel.html#update_range_style-instance_method).
+- [`IronCalc::Model`](https://jvdp.github.io/IronCalc-Ruby/IronCalc/Model.html) — the raw API. You call
+  `evaluate` yourself; in return it offers typed cell access, whole-style
+  reads and writes, and row and column default styles.
+
+### Typed cell access
+
+`set_user_input` parses what you give it, the way typing into a cell does — so
+`"007"` becomes the number 7 and `"=1+1"` becomes a formula. The typed setters
+skip that, and the typed reader gives you a Ruby object instead of a String:
+
+```ruby
+model.update_cell_with_text(0, 1, 1, "007")     # stays the string "007"
+model.update_cell_with_number(0, 1, 2, 42.5)
+model.update_cell_with_bool(0, 1, 3, true)
+model.update_cell_with_formula(0, 1, 4, "=B1*2")
+model.evaluate
+
+model.get_cell_value_by_index(0, 1, 2)  # => 42.5 (Float, not "42.5")
+model.get_cell_value_by_ref("Sheet1!D1")  # => 85.0
+model.get_cell_formula(0, 1, 4)         # => "=B1*2", or nil if not a formula
+model.is_empty_cell(0, 9, 9)            # => true
+model.get_all_cells                     # => [{ index:, row:, column: }, ...]
+```
+
+`get_all_cells` lists every cell the workbook has a record for (`index` is the
+sheet index, the engine's field name). Clearing a
+cell's contents keeps its record, so filter with `is_empty_cell` if you want
+only cells that still hold a value.
+
+Clearing works on a range, given as the engine's `Area`:
+
+```ruby
+b2_c10 = {sheet: 0, row: 2, column: 2, width: 2, height: 9}
+model.range_clear_contents(b2_c10)   # keeps the style
+model.range_clear_all(b2_c10)        # contents and style
+```
+
+On `UserModel`, `range_clear_formatting` does the opposite — style only.
+
+### Rows, columns and sheets
+
+Rows and columns can carry a default style. As with `set_cell_style`, a style is
+a complete structure, so read one, change a field, and pass it back:
+
+```ruby
+style = model.get_style_for_cell(0, 1, 1)
+style[:num_fmt] = "0.00"
+model.set_column_style(0, 2, style)
+model.get_column_style(0, 2)    # => Hash, or nil if the column has no style
+model.delete_column_style(0, 2)
+
+model.copy_cell_style([0, 1, 1], [0, 5, 5])   # style only, works across sheets
+
+model.insert_sheet("Summary", 0, nil)     # position, rather than appending
+model.set_sheet_state(1, "hidden")        # or "visible" / "veryHidden"
+```
+
+### Bulk loading
+
+`UserModel` recalculates after every action. When writing many cells, suspend
+that and evaluate once:
+
+```ruby
+um.batch do |m|
+  rows.each { |r, c, v| m.set_user_input(0, r, c, v) }
+end                             # recalculated once, here
+```
+
+`batch` nests, and recalculates even if the block raises. The underlying
+`pause_evaluation` / `resume_evaluation` pair is still available if you need to
+manage it yourself.
+
+### Defined names
+
+Named ranges, on both APIs. `scope` is a 0-based sheet index, or `nil` for a
+workbook-scoped name. They survive both an xlsx round trip and
+editing in Excel/LibreOffice, so they are also a place to keep your own
+metadata about a sheet.
+
+```ruby
+model.new_defined_name("answer", nil, "Sheet1!$C$1")
+model.set_user_input(0, 1, 1, "=answer")
+model.evaluate
+model.get_formatted_cell_value(0, 1, 1)  # => the value of C1
+
+model.defined_names
+# => [{ name: "answer", scope: nil, formula: "Sheet1!$C$1" }]
+
+model.update_defined_name("answer", nil, "result", nil, "Sheet1!$D$1")
+model.delete_defined_name("result", nil)
+```
+
+`valid_defined_name?(name, scope, formula)` reports whether
+`new_defined_name` would succeed; the name must be an identifier (`"A1"` is
+rejected — it parses as a cell reference), unused in that scope, and the formula
+must parse. `is_valid_defined_name` runs the same check but raises
+`IronCalc::Error` with the reason. On `UserModel` all three mutations are
+undoable.
+
+### Loading and saving
+
+| | `Model` | `UserModel` | save with |
+|---|---|---|---|
+| new workbook | `create` | `create_user_model` | |
+| xlsx file | `load_from_xlsx` | `create_user_model_from_xlsx` | `save_to_xlsx` |
+| xlsx in memory | `load_from_xlsx_bytes` | `create_user_model_from_xlsx_bytes` | `to_xlsx_bytes` |
+| icalc file | `load_from_icalc` | `create_user_model_from_icalc` | `save_to_icalc` |
+| icalc in memory | `load_from_bytes` | `create_user_model_from_bytes` | `to_bytes` |
+
+icalc is IronCalc's own compact format; use xlsx for anything another
+spreadsheet application should open. The constructors take
+`(name_or_path, locale, tz, language_id)`, except that the bytes variants take
+the bytes first, and the icalc ones need only the language.
+
+### Utilities
+
+```ruby
+IronCalc.number_to_column(28)          # => "AB"
+IronCalc.column_to_number("AB")        # => 28
+IronCalc.parse_reference_a1("$B3")     # => {row: 3, column: 2, absolute_row: false, absolute_column: true}
+IronCalc.quote_name("My Sheet")        # => "'My Sheet'"
+```
+
+Also `parse_reference_r1c1`, the `is_valid_*` checks, `get_supported_locales`
+and `get_all_timezones`; see the [`IronCalc` module](https://jvdp.github.io/IronCalc-Ruby/IronCalc.html).
 
 Errors raised by the engine surface as `IronCalc::Error`.
 
 ## Relationship to the Python bindings
 
 `ironcalc-ruby` is a thin binding over the same Rust engine as the
-[IronCalc Python bindings](https://github.com/ironcalc/ironcalc/tree/main/bindings/python),
-and deliberately mirrors their API. Both are compiled native extensions (Python
-via **pyo3**, Ruby via **magnus** / **rb-sys**) exposing a module named
-`ironcalc` backed by the IronCalc engine.
+[IronCalc Python bindings](https://github.com/ironcalc/ironcalc/tree/main/bindings/python).
+Both are compiled native extensions (Python via **pyo3**, Ruby via **magnus** /
+**rb-sys**) exposing a module named `ironcalc` backed by the IronCalc engine.
+
+Both follow the shape of the engine, so the two APIs line up closely and most
+Python examples translate directly. Where Python renamed an engine method, Ruby
+keeps the engine's name: Python's `clear_cell_contents(sheet, row, column)` is
+`range_clear_contents(range)` here, and `Model.get_cell_style` is
+`get_style_for_cell`. They do not cover the same amount of it —
+see [Coverage compared to the Python bindings](#coverage-compared-to-the-python-bindings).
 
 ### What's identical
 
@@ -67,10 +209,10 @@ via **pyo3**, Ruby via **magnus** / **rb-sys**) exposing a module named
   `load_from_icalc`, `load_from_bytes`, `create_user_model`,
   `create_user_model_from_xlsx`, `create_user_model_from_icalc`,
   `create_user_model_from_bytes`.
-- **Method names and signatures** on `Model` / `UserModel` — `set_user_input`,
-  `get_formatted_cell_value`, `evaluate`, `insert_rows`, `set_column_width`,
-  `new_sheet`, `save_to_xlsx`, `to_bytes`, … (Python's `snake_case` is also
-  Ruby's convention, so they match exactly).
+- **Method names and signatures** for everything both take from the engine
+  unchanged — `set_user_input`, `get_formatted_cell_value`, `evaluate`,
+  `insert_rows`, `set_column_width`, `new_sheet`, `save_to_xlsx`, `to_bytes`, …
+  (Python's `snake_case` is also Ruby's convention).
 - **Coordinates**: `sheet` is a 0-based index; `row` and `column` are 1-based.
 - **Semantics**: the same engine, so the same inputs produce the same results.
 
@@ -101,16 +243,57 @@ ports:
 |---|---|---|
 | Module access | `ic.create(...)` | `IronCalc.create(...)` |
 | Error type | `WorkbookError` | `IronCalc::Error` |
-| Cell style | typed `Style` / `Font` / … objects | plain `Hash` (`get_cell_style` / `set_cell_style`) |
+| Cell style | typed `Style` / `Font` / … objects | `Hash` with Symbol keys (`get_style_for_cell` / `set_cell_style`) |
 | Cell type | `CellType` enum | `Symbol` (`:number`, `:text`, …) |
 | Worksheet properties | list of `SheetProperty` objects | array of `Hash`es (`:name`, `:state`, `:sheet_id`, `:color`) |
 | Sheet dimensions | tuple `(min_row, max_row, min_col, max_col)` | 4-element `Array` |
+| Engine structs (`Area`, `CellIndex`) | spread into separate arguments | `Hash` keyed by the struct's field names |
+| Engine tuples | tuple | `Array` |
 | Binary data | `bytes` | binary `String` |
 | Version | `ironcalc.__version__` | `IronCalc::VERSION` |
 
 Rather than reconstruct Python's per-field style classes, Ruby exchanges styles
-as plain hashes (serialized as JSON across the boundary). Everything else is kept
-as close to the Python bindings as the two languages allow.
+as plain Hashes keyed by the engine's field names. A method that shares a
+name with an engine method takes the engine's parameters in the engine's order,
+with `nil` for an `Option`; conveniences get names of their own. So a range is
+one argument, `update_range_style({sheet: 0, row: 2, column: 2, width: 2,
+height: 9}, "font.b", "true")`, where Python spreads it into start and end
+corners.
+
+### Coverage compared to the Python bindings
+
+Both bindings wrap the same engine, so anything both expose behaves the same.
+They do not expose the same amount of it. Counted against **IronCalc 0.9.0**,
+the version this gem tracks, and accurate at the time of writing:
+
+| | Python | Ruby |
+|---|---|---|
+| `Model` | 81 | 62 |
+| `UserModel` | 119 | 52 |
+
+Most of the difference is deliberate. Selection, scrolling, clipboard and
+keyboard state belong to a UI rather than to a library, and are not exposed
+here. Conditional formatting, named styles, themes, merged cells and
+hyperlinks are a known backlog, listed explicitly in `rake parity`'s
+`ENGINE_DEFERRED` so they stay visible.
+
+What Ruby adds is mostly layering rather than extra engine coverage: Hash-based
+styles, `batch`, and xlsx in memory (`to_xlsx_bytes` / `load_from_xlsx_bytes`).
+
+These numbers move with every engine release; `rake parity` reports the
+current picture.
+
+## AI-assisted development
+
+These bindings are written and maintained with substantial help from
+[Claude Code](https://claude.com/claude-code), Anthropic's coding agent. A
+human maintainer directs the work, reviews every change and makes the releases.
+
+Correctness doesn't rest on review alone. The test suite, run in CI on every
+push, re-runs the engine's own formula regression fixtures through the binding.
+`rake parity` checks the API surface and method signatures against the engine
+and the Python bindings. The conventions agents follow here are in
+[AGENTS.md](https://github.com/jvdp/IronCalc-Ruby/blob/main/AGENTS.md).
 
 ## License
 

data/lib/ironcalc/model.rb

@@ -1,81 +1,64 @@
-require "json"
-
-# Ruby-side conveniences layered on top of the native classes. Styles cross the
-# native boundary as JSON; here we expose them as plain Ruby hashes, mirroring
-# the Node binding's serde-based approach.
+# Ruby-side helpers over the native classes, under names of their own: every
+# method named after an engine method is native and takes the engine's
+# signature.
 module IronCalc
-  class Model
-    # Returns the cell style as a Hash with string keys (snake_case, matching the
-    # engine's serde field names), e.g.
-    #   { "num_fmt" => "general", "font" => { "b" => false, ... }, ... }
+  # Prepended to {Model} and {UserModel}, so these helpers count as part of the
+  # class surface.
+  module DefinedNames
+    # Same as `get_defined_name_list`: defined names as an Array of Hashes with
+    # Symbol keys:
+    #   [{ name: "_key", scope: nil, formula: "Sheet1!$C$1" }, ...]
     #
-    # @param sheet [Integer] 0-based sheet index
-    # @param row [Integer] 1-based row
-    # @param column [Integer] 1-based column
-    # @return [Hash]
-    # @raise [IronCalc::Error]
-    def get_cell_style(sheet, row, column)
-      JSON.parse(get_cell_style_json(sheet, row, column))
+    # @return [Array<Hash>]
+    def defined_names
+      get_defined_name_list
     end
 
-    # Sets the cell style from a Hash (snake_case keys) or a JSON string.
+    # Whether {#new_defined_name} would succeed for these arguments: the boolean
+    # form of `is_valid_defined_name`, which raises with the reason instead.
     #
-    # @param sheet [Integer] 0-based sheet index
-    # @param row [Integer] 1-based row
-    # @param column [Integer] 1-based column
-    # @param style [Hash, String] the full style as a Hash or JSON string
-    # @return [void]
-    # @raise [IronCalc::Error]
-    def set_cell_style(sheet, row, column, style)
-      json = style.is_a?(String) ? style : JSON.generate(style)
-      set_cell_style_json(sheet, row, column, json)
+    # @param name [String]
+    # @param scope [Integer, nil] 0-based sheet index, or nil for workbook scope
+    # @param formula [String]
+    # @return [Boolean]
+    def valid_defined_name?(name, scope, formula)
+      is_valid_defined_name(name, scope, formula)
+      true
+    rescue Error
+      false
     end
   end
 
-  class UserModel
-    # Returns the cell style as a Hash with string keys, like {Model#get_cell_style}.
+  # Prepended rather than included, so `batch` counts as part of the class
+  # surface.
+  module Batch
+    # Suspends automatic recalculation, recalculating once when the block exits.
+    # Nested calls resume only when the outermost block returns, and the
+    # recalculation runs even if the block raises — a resumed model that was
+    # never recalculated would report stale values indefinitely.
     #
-    # @param sheet [Integer] 0-based sheet index
-    # @param row [Integer] 1-based row
-    # @param column [Integer] 1-based column
-    # @return [Hash]
-    # @raise [IronCalc::Error]
-    def get_cell_style(sheet, row, column)
-      JSON.parse(get_cell_style_json(sheet, row, column))
-    end
-
-    # Sets the cell style from a Hash (or JSON string). The user model has no
-    # whole-style setter; styling is per-property via the engine's
-    # {#update_range_style} (mirroring the WASM binding). This convenience
-    # flattens the Hash and applies each leaf with {UserModel#update_range_style}.
+    #   user_model.batch do |m|
+    #     rows.each { |row, column, value| m.set_user_input(0, row, column, value) }
+    #   end
     #
-    # @param sheet [Integer] 0-based sheet index
-    # @param row [Integer] 1-based row
-    # @param column [Integer] 1-based column
-    # @param style [Hash, String] the style as a Hash or JSON string
-    # @return [void]
-    # @raise [IronCalc::Error]
-    def set_cell_style(sheet, row, column, style)
-      desired = style.is_a?(String) ? JSON.parse(style) : style
-      flatten_style(desired).each do |path, value|
-        update_range_style(sheet, row, column, path, value.to_s)
-      end
-    end
-
-    private
-
-    # Flattens a nested style Hash to engine style paths, e.g.
-    #   { "font" => { "b" => true } } => { "font.b" => true }
-    # @api private
-    def flatten_style(hash, prefix = nil)
-      hash.each_with_object({}) do |(key, value), out|
-        path = prefix ? "#{prefix}.#{key}" : key.to_s
-        if value.is_a?(Hash)
-          out.merge!(flatten_style(value, path))
-        else
-          out[path] = value
+    # @yieldparam model [UserModel] self
+    # @return [Object] the block's value
+    def batch
+      @batch_depth = (@batch_depth || 0) + 1
+      pause_evaluation if @batch_depth == 1
+      begin
+        yield self
+      ensure
+        @batch_depth -= 1
+        if @batch_depth.zero?
+          resume_evaluation
+          evaluate
         end
       end
     end
   end
+
+  Model.prepend(DefinedNames)
+  UserModel.prepend(DefinedNames)
+  UserModel.prepend(Batch)
 end

data/lib/ironcalc/native_methods.rb

@@ -28,6 +28,18 @@ module IronCalc
   #   @return [IronCalc::Model]
   #   @raise [IronCalc::Error]
 
+  # @!method load_from_xlsx_bytes(bytes, name, locale, tz, language_id)
+  #   @!scope class
+  #   Loads a workbook from the bytes of an xlsx file into the raw {Model} API
+  #   (as produced by {Model#to_xlsx_bytes}).
+  #   @param bytes [String] binary xlsx bytes
+  #   @param name [String] workbook name
+  #   @param locale [String]
+  #   @param tz [String]
+  #   @param language_id [String]
+  #   @return [IronCalc::Model]
+  #   @raise [IronCalc::Error]
+
   # @!method load_from_icalc(file_name, language_id)
   #   @!scope class
   #   Loads a workbook from the internal binary icalc format.
@@ -64,6 +76,17 @@ module IronCalc
   #   @return [IronCalc::UserModel]
   #   @raise [IronCalc::Error]
 
+  # @!method create_user_model_from_xlsx_bytes(bytes, name, locale, tz, language_id)
+  #   @!scope class
+  #   Loads the bytes of an xlsx file into the {UserModel} API.
+  #   @param bytes [String] binary xlsx bytes
+  #   @param name [String] workbook name
+  #   @param locale [String]
+  #   @param tz [String]
+  #   @param language_id [String]
+  #   @return [IronCalc::UserModel]
+  #   @raise [IronCalc::Error]
+
   # @!method create_user_model_from_icalc(file_name, language_id)
   #   @!scope class
   #   Loads an icalc file into the {UserModel} API.
@@ -80,6 +103,93 @@ module IronCalc
   #   @return [IronCalc::UserModel]
   #   @raise [IronCalc::Error]
 
+  # @!method column_to_number(column)
+  #   @!scope class
+  #   Column identifier to 1-based number: +"AA"+ becomes 27.
+  #   @param column [String] uppercase A-Z letters
+  #   @return [Integer]
+  #   @raise [IronCalc::Error] if it is not a valid column identifier
+
+  # @!method number_to_column(column)
+  #   @!scope class
+  #   1-based number to column identifier: 27 becomes +"AA"+.
+  #   @param column [Integer]
+  #   @return [String, nil] nil when outside the sheet's columns
+
+  # @!method is_valid_column(column)
+  #   @!scope class
+  #   Whether +column+ is a column identifier within the sheet, e.g. +"AA"+.
+  #   @param column [String]
+  #   @return [Boolean]
+
+  # @!method is_valid_column_number(column)
+  #   @!scope class
+  #   Whether +column+ is a 1-based column number within the sheet.
+  #   @param column [Integer]
+  #   @return [Boolean]
+
+  # @!method is_valid_row(row)
+  #   @!scope class
+  #   Whether +row+ is a 1-based row number within the sheet.
+  #   @param row [Integer]
+  #   @return [Boolean]
+
+  # @!method is_valid_identifier(name)
+  #   Whether +name+ can be a defined name. This is {is_valid_a1_identifier}
+  #   minus the four single letters +"R"+, +"r"+, +"C"+ and +"c"+, which
+  #   spreadsheets reserve for R1C1 notation — they stay usable as LAMBDA
+  #   parameters and LET variables, so the A1 form accepts them.
+  #
+  #     IronCalc.is_valid_identifier("total")  # => true
+  #     IronCalc.is_valid_identifier("R")      # => false, the only difference
+  #     IronCalc.is_valid_identifier("A1")     # => false, a cell reference
+  #
+  #   @!scope class
+  #   @param name [String]
+  #   @return [Boolean]
+
+  # @!method is_valid_a1_identifier(name)
+  #   @!scope class
+  #   Whether +name+ can be a name in an A1-style formula. Anything that reads
+  #   as a cell reference is not one.
+  #
+  #     IronCalc.is_valid_a1_identifier("total")  # => true
+  #     IronCalc.is_valid_a1_identifier("R")      # => true
+  #     IronCalc.is_valid_a1_identifier("A1")     # => false, a cell reference
+  #
+  #   @param name [String]
+  #   @return [Boolean]
+
+  # @!method quote_name(name)
+  #   @!scope class
+  #   Quotes a sheet name if a formula reference would need it:
+  #   +"My Sheet"+ becomes +"'My Sheet'"+, +"Sheet1"+ is returned unchanged.
+  #   @param name [String]
+  #   @return [String]
+
+  # @!method parse_reference_a1(reference)
+  #   @!scope class
+  #   Parses A1 notation into +{ row:, column:, absolute_row:, absolute_column: }+,
+  #   with 1-based coordinates. +"$B$2"+ reports both absolute flags.
+  #   @param reference [String]
+  #   @return [Hash, nil] nil if it does not parse
+
+  # @!method parse_reference_r1c1(reference)
+  #   @!scope class
+  #   As {parse_reference_a1}, for R1C1 notation such as +"R2C3"+.
+  #   @param reference [String]
+  #   @return [Hash, nil] nil if it does not parse
+
+  # @!method get_supported_locales
+  #   @!scope class
+  #   Locale identifiers accepted by the constructors.
+  #   @return [Array<String>]
+
+  # @!method get_all_timezones
+  #   @!scope class
+  #   Timezone names accepted by the constructors.
+  #   @return [Array<String>]
+
   # The raw IronCalc API. You must call {#evaluate} yourself after changing
   # inputs; misuse can leave the workbook in an inconsistent state. This mirrors
   # the Python binding's `Model`. For most uses prefer {UserModel}, which
@@ -91,6 +201,11 @@ module IronCalc
     #   @return [void]
     #   @raise [IronCalc::Error]
 
+    # @!method to_xlsx_bytes
+    #   Serializes the workbook to xlsx bytes (load with {IronCalc.load_from_xlsx_bytes}).
+    #   @return [String] binary string
+    #   @raise [IronCalc::Error]
+
     # @!method save_to_icalc(file)
     #   Saves the workbook to the internal binary icalc format.
     #   @param file [String]
@@ -99,6 +214,7 @@ module IronCalc
 
     # @!method to_bytes
     #   Serializes the workbook to icalc bytes (load with {IronCalc.load_from_bytes}).
+    #   This is IronCalc's internal format, not xlsx; see {#to_xlsx_bytes}.
     #   @return [String] binary string
 
     # @!method evaluate
@@ -106,7 +222,8 @@ module IronCalc
     #   @return [void]
 
     # @!method set_user_input(sheet, row, column, value)
-    #   Sets a cell's raw input (a literal or a formula like "=A1+1").
+    #   Sets a cell's input, parsed as a user typing it would be: +"3.5"+ is a
+    #   number, +"Hello"+ a string, +"=A1*2"+ a formula.
     #   @param sheet [Integer]
     #   @param row [Integer]
     #   @param column [Integer]
@@ -114,16 +231,16 @@ module IronCalc
     #   @return [void]
     #   @raise [IronCalc::Error]
 
-    # @!method clear_cell_contents(sheet, row, column)
-    #   Clears a cell's contents (not its style).
-    #   @param sheet [Integer]
-    #   @param row [Integer]
-    #   @param column [Integer]
+    # @!method range_clear_contents(range)
+    #   Clears the contents (not the style) of every cell in a range.
+    #   @param range [Hash] the engine's +Area+: +{sheet:, row:, column:, width:,
+    #     height:}+
     #   @return [void]
     #   @raise [IronCalc::Error]
 
-    # @!method get_cell_content(sheet, row, column)
-    #   Returns the cell's content: the formula (e.g. "=A1+1") or literal text.
+    # @!method get_localized_cell_content(sheet, row, column)
+    #   Returns the cell's content in the model's locale: the formula (e.g.
+    #   "=A1+1") or literal text.
     #   @param sheet [Integer]
     #   @param row [Integer]
     #   @param column [Integer]
@@ -140,22 +257,89 @@ module IronCalc
     #   @raise [IronCalc::Error]
 
     # @!method get_formatted_cell_value(sheet, row, column)
-    #   Returns the cell's value formatted as displayed (number format applied).
+    #   The cell's value with its number format applied, as displayed — e.g.
+    #   +"$ 5.75"+.
     #   @param sheet [Integer]
     #   @param row [Integer]
     #   @param column [Integer]
     #   @return [String]
     #   @raise [IronCalc::Error]
 
-    # @!method get_cell_style_json(sheet, row, column)
-    #   @api private
-    #   JSON backing for `get_cell_style`. Prefer the Hash-returning wrapper.
-    #   @return [String]
+    # @!method get_style_for_cell(sheet, row, column)
+    #   Returns the cell style as a Hash with Symbol keys, e.g.
+    #   +{num_fmt: "general", font: {b: false, ...}, ...}+.
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @param column [Integer]
+    #   @return [Hash]
+    #   @raise [IronCalc::Error]
 
-    # @!method set_cell_style_json(sheet, row, column, style_json)
-    #   @api private
-    #   JSON backing for `set_cell_style`. Prefer the Hash-accepting wrapper.
+    # @!method set_cell_style(sheet, row, column, style)
+    #   Sets the cell style. Takes a *complete* style, as returned by
+    #   {#get_style_for_cell}: read one, change it, pass it back. Keys may be
+    #   Symbols or Strings.
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @param column [Integer]
+    #   @param style [Hash]
     #   @return [void]
+    #   @raise [IronCalc::Error] also if the style is incomplete
+
+    # @!method get_column_style(sheet, column)
+    #   The default style for a whole column, as a Hash, or nil if the column
+    #   carries no style of its own.
+    #   @param sheet [Integer]
+    #   @param column [Integer]
+    #   @return [Hash, nil]
+    #   @raise [IronCalc::Error]
+
+    # @!method get_row_style(sheet, row)
+    #   The default style for a whole row, as a Hash, or nil if the sheet holds
+    #   no record for that row. A row whose style was deleted reads back as the
+    #   default style rather than nil; the column equivalent returns nil.
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @return [Hash, nil]
+    #   @raise [IronCalc::Error]
+
+    # @!method set_column_style(sheet, column, style)
+    #   Sets the default style for a whole column. Takes a complete style, as
+    #   {#set_cell_style} does.
+    #   @param sheet [Integer]
+    #   @param column [Integer]
+    #   @param style [Hash]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method set_row_style(sheet, row, style)
+    #   Sets the default style for a whole row. Takes a complete style, as
+    #   {#set_cell_style} does.
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @param style [Hash]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method copy_cell_style(source_cell, destination_cell)
+    #   Copies one cell's style (and nothing else) onto another cell, in any sheet.
+    #   @param source_cell [Array(Integer, Integer, Integer)] +[sheet, row, column]+
+    #   @param destination_cell [Array(Integer, Integer, Integer)] +[sheet, row, column]+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method delete_column_style(sheet, column)
+    #   Removes a column's default style.
+    #   @param sheet [Integer]
+    #   @param column [Integer]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method delete_row_style(sheet, row)
+    #   Removes a row's default style.
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
 
     # @!method insert_rows(sheet, row, row_count)
     #   Inserts +row_count+ rows before +row+.
@@ -215,6 +399,32 @@ module IronCalc
     #   @return [void]
     #   @raise [IronCalc::Error]
 
+    # @!method is_column_hidden(sheet, column)
+    #   @param sheet [Integer]
+    #   @param column [Integer]
+    #   @return [Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method set_column_hidden(sheet, column, hidden)
+    #   @param sheet [Integer]
+    #   @param column [Integer]
+    #   @param hidden [Boolean]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method is_row_hidden(sheet, row)
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @return [Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method set_row_hidden(sheet, row, hidden)
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @param hidden [Boolean]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
     # @!method get_frozen_columns_count(sheet)
     #   @param sheet [Integer]
     #   @return [Integer]
@@ -225,15 +435,15 @@ module IronCalc
     #   @return [Integer]
     #   @raise [IronCalc::Error]
 
-    # @!method set_frozen_columns_count(sheet, count)
+    # @!method set_frozen_columns(sheet, frozen_columns)
     #   @param sheet [Integer]
-    #   @param count [Integer]
+    #   @param frozen_columns [Integer]
     #   @return [void]
     #   @raise [IronCalc::Error]
 
-    # @!method set_frozen_rows_count(sheet, count)
+    # @!method set_frozen_rows(sheet, frozen_rows)
     #   @param sheet [Integer]
-    #   @param count [Integer]
+    #   @param frozen_rows [Integer]
     #   @return [void]
     #   @raise [IronCalc::Error]
 
@@ -243,8 +453,10 @@ module IronCalc
     #   @return [Array<Hash>]
 
     # @!method set_sheet_color(sheet, color)
+    #   Sets the sheet tab color.
     #   @param sheet [Integer]
-    #   @param color [String] hex color, e.g. "#FF0000"
+    #   @param color [String, Array, nil] +"#RRGGBB"+, a +[theme, tint]+ pair,
+    #     or nil to clear
     #   @return [void]
     #   @raise [IronCalc::Error]
 
@@ -263,8 +475,15 @@ module IronCalc
     #   @return [void]
     #   @raise [IronCalc::Error]
 
-    # @!method rename_sheet(sheet, new_name)
-    #   @param sheet [Integer]
+    # @!method rename_sheet(old_name, new_name)
+    #   Renames the sheet called +old_name+.
+    #   @param old_name [String]
+    #   @param new_name [String]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method rename_sheet_by_index(sheet_index, new_name)
+    #   @param sheet_index [Integer]
     #   @param new_name [String]
     #   @return [void]
     #   @raise [IronCalc::Error]
@@ -277,17 +496,150 @@ module IronCalc
     #   @raise [IronCalc::Error]
 
     # Without a real def, the @!method stubs above leak to the IronCalc module
+    # @!method get_defined_name_list
+    #   Defined names as one Hash per name, with symbol keys +:name+, +:scope+
+    #   (0-based sheet index, or nil for workbook scope) and +:formula+.
+    #   Also available as {DefinedNames#defined_names}.
+    #   @return [Array<Hash>]
+
+    # @!method new_defined_name(name, scope, formula)
+    #   Adds a defined name. Fails if the name is not a valid identifier (+"A1"+
+    #   is not: it parses as a cell reference), if it is already taken in that
+    #   scope, or if the formula does not parse.
+    #   @param name [String]
+    #   @param scope [Integer, nil] 0-based sheet index, or nil for workbook scope
+    #   @param formula [String] e.g. +"Sheet1!$C$1"+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_defined_name(name, scope, new_name, new_scope, new_formula)
+    #   Renames, re-scopes and/or repoints an existing defined name.
+    #   @param name [String] the current name
+    #   @param scope [Integer, nil] the current scope
+    #   @param new_name [String]
+    #   @param new_scope [Integer, nil]
+    #   @param new_formula [String]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method delete_defined_name(name, scope)
+    #   Deletes a defined name. Fails if no name matches in that scope.
+    #   @param name [String]
+    #   @param scope [Integer, nil]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method is_valid_defined_name(name, scope, formula)
+    #   Checks whether {#new_defined_name} would succeed for these arguments,
+    #   raising with the reason if not. {DefinedNames#valid_defined_name?}
+    #   answers the same question as a boolean.
+    #   @param name [String]
+    #   @param scope [Integer, nil]
+    #   @param formula [String]
+    #   @return [Integer, nil] the +sheet_id+ of the scope's sheet (as in
+    #     +get_worksheets_properties+), or nil for workbook scope
+    #   @raise [IronCalc::Error] with the reason, e.g. the name is already taken
+    #     in that scope
+
+    # @!method range_clear_all(area)
+    #   Clears the contents *and* style of every cell in a range, removing the
+    #   cells entirely. Compare +range_clear_contents+, which keeps the style.
+    #   @param area [Hash] the engine's +Area+: +{sheet:, row:, column:, width:,
+    #     height:}+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_cell_with_text(sheet, row, column, value)
+    #   Stores +value+ as text without parsing it, so +"007"+ stays +"007"+ and
+    #   +"=1+1"+ stays a string. Compare +set_user_input+, which parses.
+    #   @param value [String]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_cell_with_number(sheet, row, column, value)
+    #   Sets a number without input parsing.
+    #   @param value [Float]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_cell_with_bool(sheet, row, column, value)
+    #   Sets a boolean without input parsing.
+    #   @param value [Boolean]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_cell_with_formula(sheet, row, column, formula)
+    #   Stores a formula directly. Call +evaluate+ afterwards.
+    #   @param formula [String] including the leading +=+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method get_cell_value_by_index(sheet, row, column)
+    #   The cell's value as a Ruby object — nil, String, Float or true/false —
+    #   unformatted. Compare +get_formatted_cell_value+, which always returns a
+    #   String, and +get_localized_cell_content+, which returns what the user typed.
+    #
+    #   The engine has no error variant here, so an error cell comes back as the
+    #   String +"#DIV/0!"+ and is indistinguishable from that literal text. Use
+    #   +get_cell_type+, which reports +:error_value+, to tell them apart.
+    #   @return [nil, String, Float, Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method get_cell_value_by_ref(cell_ref)
+    #   Like +get_cell_value_by_index+, addressed by an A1-style reference that
+    #   includes the sheet, e.g. +"Sheet1!C4"+.
+    #   @param cell_ref [String]
+    #   @return [nil, String, Float, Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method get_cell_formula(sheet, row, column)
+    #   The cell's formula including the leading +=+, or nil if it is not a
+    #   formula cell.
+    #   @return [String, nil]
+    #   @raise [IronCalc::Error]
+
+    # @!method is_empty_cell(sheet, row, column)
+    #   Whether the cell holds no content.
+    #   @return [Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method get_all_cells
+    #   Every cell the workbook holds a record for, as +{ index:, row:, column: }+
+    #   hashes (+index+ is the 0-based sheet index), ordered by sheet, then row,
+    #   then column. A cell emptied with +range_clear_contents+ keeps its record
+    #   and is still listed; combine with +is_empty_cell+ if you only want cells
+    #   that have a value.
+    #   @return [Array<Hash>]
+
+    # @!method insert_sheet(sheet_name, sheet_index, sheet_id)
+    #   Adds a sheet at +sheet_index+ rather than appending it.
+    #   @param sheet_name [String]
+    #   @param sheet_index [Integer] 0-based position to insert at
+    #   @param sheet_id [Integer, nil] normally nil, so the engine allocates one
+    #   @return [void]
+    #   @raise [IronCalc::Error] also if +sheet_id+ is already in use, which the
+    #     engine itself does not check
+
+    # @!method set_sheet_state(sheet, state)
+    #   Sets a sheet's visibility. Matches the +:state+ value reported by
+    #   +get_worksheets_properties+.
+    #   @param sheet [Integer]
+    #   @param state [String] +"visible"+, +"hidden"+ or +"veryHidden"+
+    #     (+"very_hidden"+ is also accepted)
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
     # (yardoc bug lsegal/yard#1207). Doc-only file, never loaded at runtime.
     # @!visibility private
-    def __yard_anchor__; end
+    def __yard_anchor__
+    end
   end
 
   # The recommended, higher-level IronCalc API. Auto-evaluates after every action
   # and records diffs for collaboration ({#flush_send_queue} /
   # {#apply_external_diffs}). Mirrors IronCalc's WebAssembly binding and is a
   # superset of the Python binding's `UserModel`. Styling is per-property via
-  # {UserModel#update_range_style} (the Hash convenience {UserModel#set_cell_style}
-  # is layered on top).
+  # {UserModel#update_range_style}.
   class UserModel
     # @!method save_to_xlsx(file)
     #   Saves the workbook to an xlsx file. Fails if the file already exists.
@@ -295,6 +647,12 @@ module IronCalc
     #   @return [void]
     #   @raise [IronCalc::Error]
 
+    # @!method to_xlsx_bytes
+    #   Serializes the workbook to xlsx bytes (load with
+    #   {IronCalc.create_user_model_from_xlsx_bytes}).
+    #   @return [String] binary string
+    #   @raise [IronCalc::Error]
+
     # @!method save_to_icalc(file)
     #   Saves the workbook to the internal binary icalc format.
     #   @param file [String]
@@ -303,6 +661,7 @@ module IronCalc
 
     # @!method to_bytes
     #   Serializes the workbook to icalc bytes.
+    #   This is IronCalc's internal format, not xlsx; see {#to_xlsx_bytes}.
     #   @return [String] binary string
 
     # @!method apply_external_diffs(diffs)
@@ -337,7 +696,8 @@ module IronCalc
     #   @return [Boolean]
 
     # @!method set_user_input(sheet, row, column, value)
-    #   Sets a cell's raw input (literal or formula). Triggers recalculation.
+    #   Sets a cell's input, parsed as a user typing it would be: +"3.5"+ is a
+    #   number, +"Hello"+ a string, +"=A1*2"+ a formula. Triggers recalculation.
     #   @param sheet [Integer]
     #   @param row [Integer]
     #   @param column [Integer]
@@ -345,11 +705,10 @@ module IronCalc
     #   @return [void]
     #   @raise [IronCalc::Error]
 
-    # @!method clear_cell_contents(sheet, row, column)
-    #   Clears a cell's contents (not its style).
-    #   @param sheet [Integer]
-    #   @param row [Integer]
-    #   @param column [Integer]
+    # @!method range_clear_contents(range)
+    #   Clears the contents (not the style) of every cell in a range. Undoable.
+    #   @param range [Hash] the engine's +Area+: +{sheet:, row:, column:, width:,
+    #     height:}+
     #   @return [void]
     #   @raise [IronCalc::Error]
 
@@ -370,29 +729,34 @@ module IronCalc
     #   @raise [IronCalc::Error]
 
     # @!method get_formatted_cell_value(sheet, row, column)
-    #   Returns the cell's value formatted as displayed.
+    #   The cell's value with its number format applied, as displayed — e.g.
+    #   +"$ 5.75"+.
     #   @param sheet [Integer]
     #   @param row [Integer]
     #   @param column [Integer]
     #   @return [String]
     #   @raise [IronCalc::Error]
 
-    # @!method get_cell_style_json(sheet, row, column)
-    #   @api private
-    #   JSON backing for `get_cell_style`. Prefer the Hash-returning wrapper.
-    #   @return [String]
-
-    # @!method update_range_style(sheet, row, column, style_path, value)
-    #   Sets a single style property on a cell, e.g. +update_range_style(0, 1, 1,
-    #   "font.b", "true")+. This is the user model's styling primitive (mirrors
-    #   the WASM binding); `set_cell_style` wraps it for whole-Hash convenience.
+    # @!method get_cell_style(sheet, row, column)
+    #   Returns the cell style as a Hash with Symbol keys, like
+    #   {Model#get_style_for_cell}.
     #   @param sheet [Integer]
     #   @param row [Integer]
     #   @param column [Integer]
-    #   @param style_path [String] dotted path, e.g. "font.b", "fill.fg_color"
+    #   @return [Hash]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_range_style(range, style_path, value)
+    #   Sets a single style property on every cell of a range, e.g. bold for
+    #   B2:C10: +update_range_style({sheet: 0, row: 2, column: 2, width: 2,
+    #   height: 9}, "font.b", "true")+. This is the user model's styling
+    #   primitive: the engine's UserModel has no whole-style setter.
+    #   @param range [Hash] the engine's +Area+: +{sheet:, row:, column:, width:,
+    #     height:}+
+    #   @param style_path [String] dotted path, e.g. "font.b", "fill.color"
     #   @param value [String]
     #   @return [void]
-    #   @raise [IronCalc::Error]
+    #   @raise [IronCalc::Error] also if +range+ is missing a key
 
     # @!method insert_rows(sheet, row, row_count)
     #   @param sheet [Integer]
@@ -434,20 +798,54 @@ module IronCalc
     #   @return [Float] height in pixels
     #   @raise [IronCalc::Error]
 
-    # @!method set_column_width(sheet, column, width)
+    # @!method set_columns_width(sheet, column_start, column_end, width)
+    #   Sets the width of columns +column_start+ to +column_end+, inclusive.
     #   @param sheet [Integer]
-    #   @param column [Integer]
+    #   @param column_start [Integer]
+    #   @param column_end [Integer]
     #   @param width [Float]
     #   @return [void]
     #   @raise [IronCalc::Error]
 
-    # @!method set_row_height(sheet, row, height)
+    # @!method set_rows_height(sheet, row_start, row_end, height)
+    #   Sets the height of rows +row_start+ to +row_end+, inclusive.
     #   @param sheet [Integer]
-    #   @param row [Integer]
+    #   @param row_start [Integer]
+    #   @param row_end [Integer]
     #   @param height [Float]
     #   @return [void]
     #   @raise [IronCalc::Error]
 
+    # @!method is_column_hidden(sheet, column)
+    #   @param sheet [Integer]
+    #   @param column [Integer]
+    #   @return [Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method set_columns_hidden(sheet, column_start, column_end, hidden)
+    #   Hides or shows columns +column_start+ to +column_end+, inclusive. Undoable.
+    #   @param sheet [Integer]
+    #   @param column_start [Integer]
+    #   @param column_end [Integer]
+    #   @param hidden [Boolean]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method is_row_hidden(sheet, row)
+    #   @param sheet [Integer]
+    #   @param row [Integer]
+    #   @return [Boolean]
+    #   @raise [IronCalc::Error]
+
+    # @!method set_rows_hidden(sheet, row_start, row_end, hidden)
+    #   Hides or shows rows +row_start+ to +row_end+, inclusive. Undoable.
+    #   @param sheet [Integer]
+    #   @param row_start [Integer]
+    #   @param row_end [Integer]
+    #   @param hidden [Boolean]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
     # @!method get_frozen_columns_count(sheet)
     #   @param sheet [Integer]
     #   @return [Integer]
@@ -476,8 +874,10 @@ module IronCalc
     #   @return [Array<Hash>]
 
     # @!method set_sheet_color(sheet, color)
+    #   Sets the sheet tab color.
     #   @param sheet [Integer]
-    #   @param color [String] hex color, e.g. "#FF0000"
+    #   @param color [String, Array, nil] +"#RRGGBB"+, a +[theme, tint]+ pair,
+    #     or nil to clear
     #   @return [void]
     #   @raise [IronCalc::Error]
 
@@ -503,8 +903,79 @@ module IronCalc
     #   @return [Array(Integer, Integer, Integer, Integer)]
     #   @raise [IronCalc::Error]
 
+    # @!method get_defined_name_list
+    #   Defined names as one Hash per name, with symbol keys +:name+, +:scope+
+    #   (0-based sheet index, or nil for workbook scope) and +:formula+.
+    #   Also available as {DefinedNames#defined_names}.
+    #   @return [Array<Hash>]
+
+    # @!method new_defined_name(name, scope, formula)
+    #   Adds a defined name. Fails if the name is not a valid identifier (+"A1"+
+    #   is not: it parses as a cell reference), if it is already taken in that
+    #   scope, or if the formula does not parse.
+    #   @param name [String]
+    #   @param scope [Integer, nil] 0-based sheet index, or nil for workbook scope
+    #   @param formula [String] e.g. +"Sheet1!$C$1"+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method update_defined_name(name, scope, new_name, new_scope, new_formula)
+    #   Renames, re-scopes and/or repoints an existing defined name.
+    #   @param name [String] the current name
+    #   @param scope [Integer, nil] the current scope
+    #   @param new_name [String]
+    #   @param new_scope [Integer, nil]
+    #   @param new_formula [String]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method delete_defined_name(name, scope)
+    #   Deletes a defined name. Fails if no name matches in that scope.
+    #   @param name [String]
+    #   @param scope [Integer, nil]
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method is_valid_defined_name(name, scope, formula)
+    #   Checks whether {#new_defined_name} would succeed for these arguments,
+    #   raising with the reason if not. {DefinedNames#valid_defined_name?}
+    #   answers the same question as a boolean.
+    #   @param name [String]
+    #   @param scope [Integer, nil]
+    #   @param formula [String]
+    #   @return [Integer, nil] the +sheet_id+ of the scope's sheet (as in
+    #     +get_worksheets_properties+), or nil for workbook scope
+    #   @raise [IronCalc::Error] with the reason, e.g. the name is already taken
+    #     in that scope
+
+    # @!method range_clear_all(range)
+    #   Clears the contents *and* style of every cell in a range. Undoable.
+    #   @param range [Hash] the engine's +Area+: +{sheet:, row:, column:, width:,
+    #     height:}+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method range_clear_formatting(range)
+    #   Clears the style of every cell in a range, keeping the contents. Undoable.
+    #   @param range [Hash] the engine's +Area+: +{sheet:, row:, column:, width:,
+    #     height:}+
+    #   @return [void]
+    #   @raise [IronCalc::Error]
+
+    # @!method pause_evaluation
+    #   Suspends the automatic recalculation this API does after every action —
+    #   useful when writing many cells at once. While paused, formula cells read
+    #   back as +#ERROR!+ until evaluated.
+    #   @return [void]
+
+    # @!method resume_evaluation
+    #   Re-enables automatic recalculation. Does not recalculate by itself; call
+    #   +evaluate+ afterwards to bring the workbook up to date.
+    #   @return [void]
+
     # Anchors the @!method stubs above — see {Model}.
     # @!visibility private
-    def __yard_anchor__; end
+    def __yard_anchor__
+    end
   end
 end

data/lib/ironcalc/version.rb

@@ -1,3 +1,3 @@
 module IronCalc
-  VERSION = "0.7.1.5"
+  VERSION = "0.9.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ironcalc
 version: !ruby/object:Gem::Version
-  version: 0.7.1.5
+  version: 0.9.0.0
 platform: aarch64-linux
 authors:
 - jvdp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-17 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies: []
 description: |
   Ruby bindings for the IronCalc spreadsheet engine. Create, read and
@@ -34,15 +34,16 @@ files:
 - lib/ironcalc/model.rb
 - lib/ironcalc/native_methods.rb
 - lib/ironcalc/version.rb
-homepage: https://github.com/jvdp/IronCalc-Ruby
+homepage: https://www.ironcalc.com/
 licenses:
-- MIT OR Apache-2.0
+- MIT
+- Apache-2.0
 metadata:
-  homepage_uri: https://www.ironcalc.com/
   source_code_uri: https://github.com/jvdp/IronCalc-Ruby
   bug_tracker_uri: https://github.com/jvdp/IronCalc-Ruby/issues
-  changelog_uri: https://raw.githubusercontent.com/jvdp/IronCalc-Ruby/refs/heads/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/ironcalc/
+  changelog_uri: https://github.com/jvdp/IronCalc-Ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://jvdp.github.io/IronCalc-Ruby/0.9.0/
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: