calcsheet 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 291f855f2646898ede484b6dbaca57d4cac890387ece27c70352fbb463770057
-  data.tar.gz: 4cb2e6174412b74611168b5da6daf2844fcd8f33ae5c1d88b6b4f528b777267a
+  metadata.gz: 0cb9f770dac27dff3dcc72ce14a9c5183d2654f9e8ded440f6b62c9b90b970ad
+  data.tar.gz: b6c5a2c6488c6ebf0ce1c1efd486ae352f17fac6448dee01f94ba4cbb26d20fb
 SHA512:
-  metadata.gz: c10916111f1bd9d947e7964642b7e6db53e6af1e5acd98e43c8c98067c6212a4a272d6e0a753b3cd33d5f91403f858e3b93108d7e15a8d11e11a20959dfefdfe
-  data.tar.gz: b6ee874c89945474f843bed12c44b68a84ad8e56d81bc58528a783e513fa34009c53f419340aa37c2d0d5c006f553a05abdfd22baa1145b2564715e3fe77042b
+  metadata.gz: cbb045fef9e6b52af84af31460584209c1ffc425d88c551f11508b732f4e728ece01c6ef82cef3dc41e360e53fa063c68eed6c1631a36a9b16dca29ab0025c61
+  data.tar.gz: 5c6aa201e3120996d3f0cf965556ae1c3cb039c0cf6d4b6d900ecc26d04bebf3d4aa7f92bad6183090a5e53b347ed16dc5dd5169c8d5e3ade8ab7d90b4a28a38

data/CHANGELOG.md

@@ -7,6 +7,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-28
+
+### Added
+
+- `Calcsheet::Formula.new(text, value:)` stores the formula's result, which XLSX and ODS applications that do not
+  compute formulas show and calcsheet reads back (ADR 016).
+- A column's `style:` styles its data cells that a row leaves unstyled; `book.sheet(..., header_style:)` writes the
+  header row in a style instead of bold.
+- `auto_width` measures a number as its style's number format or its column's `scale:` shows it, and a formula by
+  its stored result.
+
+### Changed
+
+- Styled rows are written about twice as fast: the XLSX and ODS writers look up each style once per number format
+  instead of hashing it for every cell.
+
 ## [0.2.0] - 2026-10-22
 
 ### Added
@@ -98,6 +114,7 @@ First release.
 - Report vulnerabilities as described in
   [SECURITY.md](https://gitlab.opinioni.net/demetra-developers/rubygems/calcsheet/-/blob/main/SECURITY.md).
 
-[Unreleased]: https://gitlab.opinioni.net/demetra-developers/rubygems/calcsheet/-/compare/v0.2.0...develop
+[Unreleased]: https://gitlab.opinioni.net/demetra-developers/rubygems/calcsheet/-/compare/v0.3.0...develop
+[0.3.0]: https://gitlab.opinioni.net/demetra-developers/rubygems/calcsheet/-/compare/v0.2.0...v0.3.0
 [0.2.0]: https://gitlab.opinioni.net/demetra-developers/rubygems/calcsheet/-/compare/v0.1.0...v0.2.0
 [0.1.0]: https://gitlab.opinioni.net/demetra-developers/rubygems/calcsheet/-/tags/v0.1.0

data/README.md

@@ -45,7 +45,7 @@ Calcsheet will be published on [rubygems.org](https://rubygems.org/gems/calcshee
 release. Once it is released, add it to your Gemfile:
 
 ```rb
-gem "calcsheet", "~> 0.2"
+gem "calcsheet", "~> 0.3"
 ```
 
 The runtime dependencies are `ox` (a SAX parser with a C extension), `rubyzip`, `zip_kit`, `bigdecimal` and `csv`.
@@ -322,6 +322,7 @@ are written one after another, and a finished sheet cannot be reopened. Each col
 | `scale:` | `nil` | Decimals shown by XLSX and ODS for a `:decimal` column. Display only: see below. |
 | `key:` | `nil` | The key of the column in Hash rows, instead of the header. |
 | `formula_protection:` | `true` | CSV only: see [formula protection](#formula-protection). |
+| `style:` | `nil` | The name of a style for the column's data cells (XLSX and ODS): see [styles](#styles-formulas-and-merges). |
 
 `sheet << row` takes an Array in column order or a Hash (an unknown key raises `ArgumentError`). Every value must
 fit its column type, otherwise `Calcsheet::WriteError` names the sheet, row and column, nothing of that row is
@@ -359,19 +360,27 @@ Calcsheet.write("report.xlsx") do |book|
   book.style(:head, bold: true, fill: "DDEEFF", wrap: true, valign: :top,
                     border: { style: :thin, color: "000000", edges: %i[top bottom] })
   book.style(:percent, format: "0.0 %")
+  book.style(:money, format: "#,##0.00")
 
   book.sheet("Answers", auto_width: true) do |sheet|        # no columns: a free sheet
     sheet.merge("A1:C1")                                     # before the row it starts on
     sheet.add(["Answers to question 1", nil, nil], style: :title)
     sheet.add(["Answer", "Count", "Share"], style: :head)
-    sheet << ["Yes", 30, Calcsheet::Formula.new("B3/B5")]
-    sheet << ["No", 10, Calcsheet::Formula.new("B4/B5")]
-    sheet.add(["Total", Calcsheet::Formula.new("SUM(B3:B4)"), 1], style: [nil, nil, :percent])
+    sheet.add(["Yes", 30, Calcsheet::Formula.new("B3/B5")], style: [nil, nil, :percent])
+    sheet.add(["No", 10, Calcsheet::Formula.new("B4/B5")], style: [nil, nil, :percent])
+    sheet << ["Total", Calcsheet::Formula.new("SUM(B3:B4)", value: 40)]   # with its result
+  end
+
+  book.sheet("Prices", header_style: :head, columns: [
+    { header: "Code" },
+    { header: "Price", type: :decimal, style: :money }                # the style of the column's cells
+  ]) do |sheet|
+    sheet << ["00013", BigDecimal("1234.5")]
   end
 end
 
 Calcsheet.open("report.xlsx") do |book|
-  book.rows(header: false).map(&:values).last   # => ["Total", nil, 1]
+  book.rows(header: false).map(&:values).last   # => ["Total", 40]
 end
 ```
 
@@ -383,22 +392,26 @@ end
 `"0.0 %"` (0.25 shows as 25.0 %), dates and times from `yyyy`, `mm`, `dd`, `hh`, `ss` (`"dd/mm/yyyy"`, `"hh:mm"`),
 or `"@"` for text. An unknown attribute or value raises `ArgumentError`. `sheet.add(row, style:)` writes a row as
 `<<` does, with the name of a style for every cell or an Array of names (or `nil`) by column; a style given for a
-column beyond the values styles an empty cell (the border of a merged title). XLSX and ODS apply styles, CSV ignores
-them.
+column beyond the values styles an empty cell (the border of a merged title). In a sheet with columns, a column's
+`style:` styles its data cells that the row leaves unstyled, and `book.sheet(..., header_style: :name)` writes the
+header row in that style instead of bold. XLSX and ODS apply styles, CSV ignores them.
 
 - **Free sheets.** `book.sheet(name)` without `columns:` writes rows of any length (Arrays only, no header row), each
   value with the type of its class: `String`, `Integer`, `BigDecimal`, `Date`, `Time`, `true`, `false`; a `Float` or
   a `DateTime` raises `WriteError`, as in a typed column. `widths: [12, nil, 30]` sets their column widths.
 - **Formulas.** `Calcsheet::Formula.new("SUM(B3:B4)")` (a leading `=` is optional) writes a formula in any sheet and
   column, in the syntax of Excel: ODS gets it translated to OpenFormula (`of:=SUM([.B3:.B4])`, `;` between
-  arguments), CSV writes the text `=SUM(B3:B4)`. No result is stored: Excel and LibreOffice compute it when they open
-  the file, and calcsheet reads such a cell back as `nil`.
+  arguments), CSV writes the text `=SUM(B3:B4)`. Excel and LibreOffice compute it when they open the file;
+  `Formula.new("B3/B5", value: BigDecimal("0.75"))` also stores its result (a `String`, an `Integer`, a finite
+  `BigDecimal`, `true` or `false`), which applications that do not compute formulas (previews, calcsheet itself) show.
+  Without it they show an empty cell, and calcsheet reads it back as `nil`.
 - **Merges.** `sheet.merge("A1:C1")` merges a range, rows counted from the first of the sheet (the header included).
   ODS writes a merge on its first cell, so it must be declared before that row is written; the other cells it covers
   must be empty (`WriteError` otherwise), and a merge may not overlap another. CSV ignores merges.
 - **`auto_width: true`** gives each column without a `width:` the width of its longest value, headers included, in
-  characters scaled by the style's font size and weight (a rough measure, as Excel's own autofit is). Formulas and
-  the first cell of a merge across columns are not measured; `sheet.add(row, measure: false)` leaves out a row such
+  characters scaled by the style's font size and weight (a rough measure, as Excel's own autofit is); a number counts
+  as its style's number format or its column's `scale:` shows it, a formula as its stored result. Formulas without
+  one and the first cell of a merge across columns are not measured; `sheet.add(row, measure: false)` leaves out a row such
   as a long note. The widths come before the rows in both formats, so the rows of an `auto_width` sheet wait in a
   temporary file until the sheet ends.
 
@@ -765,7 +778,7 @@ Reading:
 
 Writing:
 
-- The header row is bold and frozen (XLSX `pane`, ODS `settings.xml`) when `header: true`. Columns get their
+- The header row is bold (or in its `header_style:`) and frozen (XLSX `pane`, ODS `settings.xml`) when `header: true`. Columns get their
   `width:`; ODS widths are rounded to whole characters, from 1 to 255.
 - Styles (see [styles, formulas and merges](#styles-formulas-and-merges)) are XLSX cell formats with their fonts,
   fills and borders, and ODS common cell styles `Calcsheet1`, `Calcsheet2`... in `styles.xml`. A workbook with
@@ -905,7 +918,7 @@ never needs a Rust toolchain.
 nothing in your code changes:
 
 ```rb
-gem "calcsheet", "~> 0.2"
+gem "calcsheet", "~> 0.3"
 gem "calcsheet-native"
 ```
 

data/lib/calcsheet/column.rb

@@ -15,11 +15,16 @@ module Calcsheet
   # @attr_reader key [Object, nil] the key of the column in Hash rows, instead of the header
   # @attr_reader formula_protection [Boolean] CSV prefixes text starting with a formula character with "'" (see
   #   FormulaProtection): the cells of a +:string+ column, and the header of any column; default true
-  Column = Data.define(:header, :type, :width, :scale, :key, :formula_protection) do
+  # @attr_reader style [Symbol, nil] the name of a style of the book (WriteBook#style) for the column's data cells
+  #   that a row does not style (XLSX and ODS)
+  Column = Data.define(:header, :type, :width, :scale, :key, :formula_protection, :style) do
     # @raise [ArgumentError] on an invalid attribute
-    def initialize(header: nil, type: :string, width: nil, scale: nil, key: nil, formula_protection: true)
+    def initialize(header: nil, type: :string, width: nil, scale: nil, key: nil, formula_protection: true, style: nil)
+      raise ArgumentError, "column: style: must be a Symbol or nil, got #{style.inspect}" unless style.nil? || style.is_a?(Symbol)
+
       super(header: Column.checked_header(header), type: Column.checked_type(type), width: Column.checked_width(width),
-            scale: Column.checked_scale(scale), key: key, formula_protection: Column.checked_protection(formula_protection))
+            scale: Column.checked_scale(scale), key: key, formula_protection: Column.checked_protection(formula_protection),
+            style: style)
     end
 
     # A copy with +changes+, validated like +new+. Defined here because Data#with does not call +initialize+ on
@@ -41,7 +46,8 @@ module Calcsheet
     MAX_WIDTH = 255
 
     class << self
-      # @param entry [Hash, Column] { header:, type: :string, width: nil, scale: nil, key: nil, formula_protection: true }
+      # @param entry [Hash, Column] { header:, type: :string, width: nil, scale: nil, key: nil, formula_protection: true,
+      #   style: nil }
       # @return [Column]
       # @raise [ArgumentError] on an invalid entry
       def from(entry)

data/lib/calcsheet/formula.rb

@@ -1,19 +1,34 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
 require_relative "column"
 
 module Calcsheet
   # A formula to write in a cell, in the syntax of Excel: +Formula.new("SUM(B2:B5)")+ (a leading "=" is dropped).
   # XLSX writes it as is, ODS translates its references and argument separators to OpenFormula, CSV writes it as the
-  # text "=SUM(B2:B5)". No value is cached with it: Excel and LibreOffice compute it when they open the file, and
-  # calcsheet reads such a cell back as nil.
+  # text "=SUM(B2:B5)". Excel and LibreOffice compute it when they open the file. Its +value:+, when given, is
+  # stored with it as its result: applications and readers that do not compute formulas (previews, calcsheet itself)
+  # show it, and without it they show an empty cell (calcsheet reads it as nil).
   #
   # @attr_reader text [String] the formula without its leading "=", frozen UTF-8
-  Formula = Data.define(:text) do
+  # @attr_reader value [String, Integer, BigDecimal, Boolean, nil] the stored result, nil for none
+  Formula = Data.define(:text, :value) do
+    class << self
+      alias_method :data_new, :new
+
+      # Takes the text as the only positional argument, with or without +value:+:
+      # +Formula.new("B3/B5", value: BigDecimal("0.6"))+.
+      def new(*arguments, **keywords)
+        arguments.size == 1 ? data_new(text: arguments.first, **keywords) : data_new(*arguments, **keywords)
+      end
+    end
+
     # @param text [String]
+    # @param value [String, Integer, BigDecimal, true, false, nil] the result to store; a Float is refused, as in a
+    #   +:decimal+ column, so that no binary rounding slips in
     # @raise [ArgumentError] unless +text+ is a non-empty String convertible to UTF-8, of at most MAX_LENGTH
-    #   characters
-    def initialize(text:)
+    #   characters, and +value+ one of those
+    def initialize(text:, value: nil)
       unless text.is_a?(String) && (utf8 = Column.utf8(text))
         raise ArgumentError, "formula: expected a String convertible to UTF-8, got #{text.inspect}"
       end
@@ -24,7 +39,7 @@ module Calcsheet
         raise ArgumentError, "formula: #{utf8.length} characters, more than the #{Formula::MAX_LENGTH} of Excel"
       end
 
-      super(text: utf8.freeze)
+      super(text: utf8.freeze, value: Formula.result(value))
     end
 
     # @return [String] the formula as a spreadsheet shows it, with its "="
@@ -36,5 +51,23 @@ module Calcsheet
   class Formula
     # The longest formula Excel accepts, in characters.
     MAX_LENGTH = 8_192
+    # @api private
+    # The cell type a stored result is written as, by its class.
+    RESULT_TYPES = { String => :string, Integer => :integer, BigDecimal => :decimal, TrueClass => :boolean,
+                     FalseClass => :boolean }.freeze
+
+    # @api private
+    # A checked result: a String as frozen UTF-8.
+    def self.result(value)
+      case value
+      when nil, true, false, Integer then return value
+      when BigDecimal then return value if value.finite?
+      when String
+        utf8 = Column.utf8(value)
+        return utf8.frozen? ? utf8 : utf8.dup.freeze if utf8
+      end
+      raise ArgumentError, "formula: value: expected a String, an Integer, a finite BigDecimal, true, false or nil, " \
+                           "got #{value.inspect}"
+    end
   end
 end

data/lib/calcsheet/version.rb

@@ -2,5 +2,5 @@
 
 module Calcsheet
   # The version of the gem.
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/calcsheet/write_book.rb

@@ -24,12 +24,13 @@ module Calcsheet
   #   call, which win over presets. It runs before anything is written, also when Calcsheet.stream builds its body.
   # - +.new(io, options)+: +io+ responds to +write(string)+ and +<<(string)+ and may be non-seekable; +options+ are
   #   those prepared, frozen. The backend must not close +io+.
-  # - +#start_sheet(name, columns, header:, widths: nil, auto_width: false)+, for each sheet and each continuation:
-  #   +name+ is valid and unique, +columns+ an Array of frozen Column, or nil for a free sheet (no columns: each
-  #   cell has the type of its value, see #row), whose column widths +widths+ gives (an Array of Numeric or nil, by
-  #   column index); with +header: true+ (never for a free sheet) the backend writes the header row (the column
-  #   headers) itself. With +auto_width: true+ the widths of the columns without one come with #end_sheet, after the
-  #   rows: the backend keeps the rows (in a temporary file) until then.
+  # - +#start_sheet(name, columns, header:, widths: nil, auto_width: false, header_style: nil)+, for each sheet and
+  #   each continuation: +name+ is valid and unique, +columns+ an Array of frozen Column, or nil for a free sheet
+  #   (no columns: each cell has the type of its value, see #row), whose column widths +widths+ gives (an Array of
+  #   Numeric or nil, by column index); with +header: true+ (never for a free sheet) the backend writes the header row (the column
+  #   headers) itself, bold, or in the Style +header_style+ when given. With +auto_width: true+ the widths of the
+  #   columns without one come with #end_sheet, after the rows: the backend keeps the rows (in a temporary file)
+  #   until then. The facade passes only the keywords a sheet uses beyond +header:+.
   # - +#row(values, styles = nil)+: one value per column, in column order: nil (empty cell), a Formula, or a value of
   #   the column type — String in UTF-8 (:string), Integer (:integer), Integer or finite BigDecimal (:decimal,
   #   written unrounded; +scale+ is display only), Date (:date), true/false (:boolean), and for :datetime a UTC
@@ -182,13 +183,15 @@ module Calcsheet
     #   sheet has its columns' +width:+)
     # @param auto_width [Boolean] the columns without a width get the width of their longest value (XLSX and ODS):
     #   the rows are kept in a temporary file until the sheet ends
+    # @param header_style [Symbol, nil] the name of a style (#style) for the header row instead of bold (XLSX and
+    #   ODS)
     # @yieldparam sheet [WriteSheet]
     # @return [nil]
     # @raise [ArgumentError] a missing block, invalid columns, widths or name, too many columns for the format, a
     #   sheet opened inside another one's block, or a book already finished
     # @raise [WriteError] an earlier sheet block raised; a second sheet in CSV; a header longer than an XLSX cell, or
     #   (written) than +max_cell_bytes+; the sheet is not started
-    def sheet(name, columns: nil, header: nil, widths: nil, auto_width: false)
+    def sheet(name, columns: nil, header: nil, widths: nil, auto_width: false, header_style: nil)
       raise ArgumentError, "a block is required" unless block_given?
 
       check_usable
@@ -196,7 +199,7 @@ module Calcsheet
 
       sheet = @sheet = WriteSheet.new(@writer, @names, name, columns, header: header.nil? ? !columns.nil? : header,
                                       limit: @limit, zone: @zone, max_cell_bytes: @max_cell_bytes, styles: @styles,
-                                      widths: widths, auto_width: auto_width)
+                                      widths: widths, auto_width: auto_width, header_style: header_style)
       completed = false
       begin
         yield sheet

data/lib/calcsheet/write_sheet.rb

@@ -59,7 +59,7 @@ module Calcsheet
     # @raise [ArgumentError] on invalid columns, name, limit or widths
     # @raise [WriteError] for a written header longer than +max_cell_bytes+, or one the backend refuses
     def initialize(writer, names, name, columns, header:, limit:, zone:, max_cell_bytes: nil, styles: {}, widths: nil,
-                   auto_width: false)
+                   auto_width: false, header_style: nil)
       if columns.nil?
         raise ArgumentError, "header: a sheet without columns: has no header" if header
       elsif !columns.is_a?(Array) || columns.empty?
@@ -76,6 +76,13 @@ module Calcsheet
       @header = header
       @styles = styles
       @auto_width = auto_width
+      @column_styles = @columns&.map { _1.style && lookup_style(_1.style) }
+      @column_styles = nil unless @column_styles&.any?
+      if header_style && !@header
+        raise ArgumentError, "header_style: a sheet without a header row has no header to style"
+      end
+
+      @header_style = header_style && lookup_style(header_style)
       if @header && limit && limit < 2
         raise ArgumentError, "max_rows_per_sheet: #{limit} leaves no room for data rows after the header"
       end
@@ -194,11 +201,9 @@ module Calcsheet
     end
 
     def start(name)
-      if @columns.nil? || @auto_width
-        @writer.start_sheet(name, @columns, header: @header, widths: @widths, auto_width: @auto_width)
-      else
-        @writer.start_sheet(name, @columns, header: @header)
-      end
+      options = @columns.nil? || @auto_width ? { widths: @widths, auto_width: @auto_width } : {}
+      options[:header_style] = @header_style if @header_style
+      @writer.start_sheet(name, @columns, header: @header, **options)
       @name = name
       @rows = @header ? 1 : 0
       @merges = []
@@ -269,7 +274,7 @@ module Calcsheet
     end
 
     def cell(value, index)
-      return value if value.is_a?(Formula)
+      return formula(value, index) if value.is_a?(Formula)
 
       type = @types ? @types[index] : free_type(value, index)
       case type
@@ -293,6 +298,15 @@ module Calcsheet
       raise failure("expected #{EXPECTED.fetch(type)} (:#{type} column), got #{Untrusted.show(value)}", index)
     end
 
+    # A formula whose stored result the readers would refuse, as a cell value, raises.
+    def formula(value, index)
+      case (result = value.value)
+      when Integer, BigDecimal then number(result, index)
+      when String then long_text(result, index) unless result.bytesize < @short_text
+      end
+      value
+    end
+
     # The type of a value of a free sheet: the type #cell checks it as.
     def free_type(value, index)
       case value
@@ -310,9 +324,17 @@ module Calcsheet
       end
     end
 
-    # The Styles of a row by column index, nil without any.
+    # The Styles of a row by column index, nil without any: the row's, and the columns' style where the row gives
+    # none.
     # @raise [ArgumentError] an unknown name or another value
     def styles_of(style, size)
+      styles = row_styles(style, size)
+      return styles || @column_styles if styles.nil? || @column_styles.nil?
+
+      Array.new(@column_styles.size) { |index| styles[index] || @column_styles[index] }
+    end
+
+    def row_styles(style, size)
       case style
       when nil then nil
       when Symbol then Array.new(@columns ? @columns.size : size, lookup_style(style))
@@ -364,32 +386,52 @@ module Calcsheet
       end
     end
 
+    # The headers are bold, or in the header style.
     def measure_headers
-      @columns.each_with_index { |column, index| widen(index, column.header.length * 1.1) }
+      factor = @header_style ? font_factor(@header_style) : 1.1
+      @columns.each_with_index { |column, index| widen(index, column.header.length * factor) }
+    end
+
+    # How much wider than the default font a style's text is, roughly.
+    def font_factor(style)
+      (style.size || DEFAULT_SIZE).fdiv(DEFAULT_SIZE) * (style.bold ? 1.1 : 1)
     end
 
     # Widens the columns to the characters of the values, scaled by their style's font: a rough measure, as Excel's
-    # own autofit is, of the text the cell shows. Formulas are not measured: their result is not known, nor the first
-    # cell of a merge across columns, whose text spans them.
+    # own autofit is, of the text the cell shows. A formula counts by its stored result, if any; the first cell of a
+    # merge across columns, whose text spans them, is not measured.
     def measure(values, styles)
       row = @rows + 1
       spanning = @merges.select { _1.first_row == row && _1.last_column > _1.first_column }.map(&:first_column)
       values.each_with_index do |value, index|
         next if spanning.include?(index)
 
-        characters =
-          case value
-          when nil, Formula then next
-          when String then value.each_line.map { _1.chomp.length }.max || 0
-          when Integer then value.to_s.length
-          when BigDecimal then DecimalText.plain(value).length
-          when Time then DATETIME_CHARACTERS
-          when Date then DATE_CHARACTERS
-          else BOOLEAN_CHARACTERS
-          end
+        value = value.value if value.is_a?(Formula)
+        next if value.nil?
+
         style = styles&.[](index)
-        factor = (style&.size || DEFAULT_SIZE).fdiv(DEFAULT_SIZE) * (style&.bold ? 1.1 : 1)
-        widen(index, characters * factor)
+        widen(index, characters(value, index, style) * (style ? font_factor(style) : 1))
+      end
+    end
+
+    # The characters a value shows, as #measure counts them: a number as its style's number format, or its column's
+    # +scale:+, shows it.
+    def characters(value, index, style)
+      case value
+      when String then value.each_line.map { _1.chomp.length }.max || 0
+      when Integer, BigDecimal
+        format = style&.format
+        if format && %i[number percent].include?(format.kind)
+          shown_number(value, format.decimals, grouping: format.grouping,
+                                               suffix: format.kind == :percent ? format.code[/ ?%\z/].length : 0)
+        elsif (scale = @columns&.[](index)&.scale)
+          shown_number(value, scale)
+        else
+          value.is_a?(Integer) ? value.to_s.length : DecimalText.plain(value).length
+        end
+      when Time then DATETIME_CHARACTERS
+      when Date then DATE_CHARACTERS
+      else BOOLEAN_CHARACTERS
       end
     end
 
@@ -398,6 +440,16 @@ module Calcsheet
       @measured[index] = width if @measured[index].nil? || @measured[index] < width
     end
 
+    # The characters of a number shown with +decimals+ decimals, its thousands grouped or not, before +suffix+
+    # characters (a percentage's " %", whose number is the value times 100).
+    def shown_number(value, decimals, grouping: false, suffix: 0)
+      value *= 100 if suffix.positive?
+      rounded = BigDecimal(value).round(decimals)
+      digits = rounded.abs.to_i.to_s.length
+      (rounded.negative? ? 1 : 0) + digits + (grouping ? (digits - 1) / 3 : 0) + (decimals.positive? ? decimals + 1 : 0) +
+        suffix
+    end
+
     # A number whose written text (the full digits of an Integer, the plain text of a BigDecimal) is longer than
     # Cast::MAX_NUMBER_BYTES would make the file unreadable: the readers refuse longer numbers. The length is
     # computed without the text, which for BigDecimal("1e500000000") would take gigabytes. An Integer comes here only

data/lib/calcsheet/writers/csv_writer.rb

@@ -69,7 +69,7 @@ module Calcsheet
 
       # Writes the BOM, if any, and the header row.
       # @raise [WriteError] for a second sheet
-      def start_sheet(name, columns, header:, widths: nil, auto_width: false) # rubocop:disable Lint/UnusedMethodArgument
+      def start_sheet(name, columns, header:, widths: nil, auto_width: false, header_style: nil) # rubocop:disable Lint/UnusedMethodArgument
         raise WriteError.new("a CSV file holds a single sheet: cannot start sheet '#{name}'", sheet: name) if @started
 
         @started = true

data/lib/calcsheet/writers/ods_writer.rb

@@ -167,6 +167,8 @@ module Calcsheet
         @sheets = []
         @styles = {}
         @custom_styles = {}
+        # The table:style-name attribute of a cell by its Style (by identity, nil for none) and data style.
+        @cell_attributes = {}.compare_by_identity
         @data_styles = {}
         @deferred = nil
       end
@@ -174,7 +176,7 @@ module Calcsheet
       # Starts the sheet's table in content.xml, with its columns and header row; with +auto_width+, the rows go to a
       # temporary file and the table is written when the sheet ends, its column widths known.
       # @raise [ArgumentError] for more columns than ODS holds
-      def start_sheet(name, columns, header:, widths: nil, auto_width: false)
+      def start_sheet(name, columns, header:, widths: nil, auto_width: false, header_style: nil)
         check_columns(name, columns, "ODS") if columns
         @sheets << [ name, header ]
         @name = name
@@ -183,13 +185,14 @@ module Calcsheet
         @row_number = 0
         @merges = []
         prepare_cells(columns) if columns
+        @value_styles = columns&.map { |column| (name = cell_style(column)) && "N#{name}".freeze }
         if auto_width
           flush
           defer_rows
         else
           @buffer << table_start(columns ? columns.map(&:width) : widths || [])
         end
-        write_header(columns) if header
+        write_header(columns, header_style) if header
       end
 
       # @param range [CellRange] spanned by its first cell when its first row is written
@@ -331,10 +334,16 @@ module Calcsheet
         count == 1 ? EMPTY_CELL : %(<table:table-cell table:number-columns-repeated="#{count}"/>)
       end
 
-      def write_header(columns)
-        use_style(HEADER_STYLE)
+      # The header row, bold or in +header_style+ (a Style).
+      def write_header(columns, header_style)
+        if header_style
+          start = %(<table:table-cell#{style_attribute(header_style, nil)} office:value-type="string")
+        else
+          use_style(HEADER_STYLE)
+          start = HEADER_START
+        end
         @buffer << "<table:table-row>"
-        columns.each { text_cell(HEADER_START, _1.header) }
+        columns.each { text_cell(start, _1.header) }
         @buffer << "</table:table-row>"
         @row_number = 1
       end
@@ -410,14 +419,21 @@ module Calcsheet
         attributes
       end
 
+      # A formula's stored result, if any, is written as a value of its class's type after the formula attribute, with
+      # the data style of a free sheet's value of that type.
       def any_cell(value, index, style, spans)
         type = value.nil? ? nil : type_of(value, index)
-        attributes = style_attribute(style, type && value_style(type, index)) + spans
+        if type == :formula
+          formula = XmlText.escape(OpenFormula.from_excel(value.text)).gsub(ATTRIBUTE_BREAKS, ATTRIBUTE_SPACE)
+          spans += %( table:formula="#{formula}")
+          value = value.value
+          type = value.nil? ? nil : Formula::RESULT_TYPES.fetch(value.class)
+          attributes = style_attribute(style, type && free_value_style(type)) + spans
+        else
+          attributes = style_attribute(style, type && value_style(type, index)) + spans
+        end
         case type
         when nil then @buffer << "<table:table-cell#{attributes}/>"
-        when :formula
-          formula = XmlText.escape(OpenFormula.from_excel(value.text)).gsub(ATTRIBUTE_BREAKS, ATTRIBUTE_SPACE)
-          @buffer << "<table:table-cell#{attributes} table:formula=\"#{formula}\"/>"
         when :string then text_cell(%(<table:table-cell#{attributes} office:value-type="string"), value)
         when :integer, :decimal
           text = type == :integer ? value.to_s : DecimalText.plain(value)
@@ -459,21 +475,25 @@ module Calcsheet
       # The name of the data style a cell of +type+ takes without a style that gives one: its column's, or a date's,
       # time's or boolean's.
       def value_style(type, index)
-        if @columns && type != :formula
-          name = cell_style(@columns[index])
-          return name && "N#{name}"
-        end
+        @columns ? @value_styles[index] : free_value_style(type)
+      end
 
+      def free_value_style(type)
         case type
-        when :date then use_style(DATE_STYLE) && "N#{DATE_STYLE}"
-        when :datetime then use_style(DATETIME_STYLE) && "N#{DATETIME_STYLE}"
-        when :boolean then use_style(BOOLEAN_STYLE) && "N#{BOOLEAN_STYLE}"
+        when :date then use_style(DATE_STYLE) && "NDate"
+        when :datetime then use_style(DATETIME_STYLE) && "NDatetime"
+        when :boolean then use_style(BOOLEAN_STYLE) && "NBoolean"
         end
       end
 
       # The table:style-name attribute of a cell: a common style for its Style with its data style (the Style's
       # format, else +value_style+), the plain data style's cell style without a Style, nothing without either.
       def style_attribute(style, data_style)
+        by_data_style = @cell_attributes[style] ||= {}
+        by_data_style.fetch(data_style) { by_data_style[data_style] = new_style_attribute(style, data_style).freeze }
+      end
+
+      def new_style_attribute(style, data_style)
         if style.nil?
           return "" if data_style.nil?
 

data/lib/calcsheet/writers/xlsx_writer.rb

@@ -72,6 +72,8 @@ module Calcsheet
         @fills = { nil => 0, gray125: 1 }
         @borders = { nil => 0 }
         @letters_cache = {}
+        # The s attribute of a cell by its Style (by identity, nil for none) and number format code: one lookup per cell.
+        @cell_attributes = {}.compare_by_identity
         @formulas = false
         @buffer = new_buffer
         @entry = nil
@@ -82,7 +84,7 @@ module Calcsheet
       # go to a temporary file and the entry is written when the sheet ends, its widths known.
       # @raise [ArgumentError] for more columns than XLSX holds
       # @raise [WriteError] for a header longer than a cell holds
-      def start_sheet(name, columns, header:, widths: nil, auto_width: false)
+      def start_sheet(name, columns, header:, widths: nil, auto_width: false, header_style: nil)
         check_sheet(name, columns) if columns
         @sheet_names << name
         @name = name
@@ -92,12 +94,13 @@ module Calcsheet
         @row_number = 0
         @merges = []
         prepare_cells(columns) if columns
+        @column_formats = columns&.map { format_of(_1) }
         if auto_width
           defer_rows
         else
           open_sheet_entry(cols(columns ? columns.map(&:width) : widths || []))
         end
-        write_header(columns) if header
+        write_header(columns, header_style) if header
       end
 
       # Writes one row of checked values (see the contract in WriteBook): a typed row without styles or formulas from
@@ -287,7 +290,7 @@ module Calcsheet
           value = values[index]
           style = styles&.[](index)
           if value.nil?
-            @buffer << '<c r="' << letter(index) << number << '" s="' << xf(style, nil).to_s << '"/>' if style
+            @buffer << '<c r="' << letter(index) << number << '"' << cell_attribute(style, nil) << "/>" if style
           else
             any_cell(value, index, number, style)
           end
@@ -304,12 +307,9 @@ module Calcsheet
       def any_cell(value, index, number, style)
         type = type_of(value, index)
         code = style&.format&.code || default_format(type, index)
-        @buffer << '<c r="' << letter(index) << number << '"'
-        @buffer << ' s="' << xf(style, code).to_s << '"' if style || code
+        @buffer << '<c r="' << letter(index) << number << '"' << cell_attribute(style, code)
         case type
-        when :formula
-          @formulas = true
-          @buffer << "><f>" << XmlText.escape(value.text) << "</f></c>"
+        when :formula then formula_cell(value, index)
         when :string
           @buffer << ' t="inlineStr"><is><t xml:space="preserve">'
           value_text(value, :string, index)
@@ -322,6 +322,23 @@ module Calcsheet
         end
       end
 
+      # A formula with its stored result, if any, after the cell's style: t="str" for a text, t="b" for a boolean.
+      def formula_cell(formula, index)
+        @formulas = true
+        result = formula.value
+        case result
+        when String then @buffer << ' t="str"'
+        when true, false then @buffer << ' t="b"'
+        end
+        @buffer << "><f>" << XmlText.escape(formula.text) << "</f>"
+        unless result.nil?
+          @buffer << "<v>"
+          value_text(result, Formula::RESULT_TYPES.fetch(result.class), index)
+          @buffer << "</v>"
+        end
+        @buffer << "</c>"
+      end
+
       # The type a value is written as: a formula, its column's type, or in a free sheet its class's.
       def type_of(value, index)
         return :formula if value.is_a?(Formula)
@@ -339,7 +356,7 @@ module Calcsheet
 
       # The number format of a cell without a style that gives one: its column's, or a date's or time's.
       def default_format(type, index)
-        return format_of(@columns[index]) if @columns && type != :formula
+        return @column_formats[index] if @columns && type != :formula
 
         case type
         when :date then DATE_FORMAT
@@ -357,6 +374,14 @@ module Calcsheet
 
       # The cellXfs index of a Style with a number format code (either may be nil), registered at its first use; a
       # Style that sets only the number format shares the index of that format.
+      # The s attribute of a cell with a Style and a number format code (either may be nil, then "" for both).
+      def cell_attribute(style, code)
+        by_code = @cell_attributes[style] ||= {}
+        by_code.fetch(code) do
+          by_code[code] = style.nil? && code.nil? ? "" : %( s="#{xf(style, code)}").freeze
+        end
+      end
+
       def xf(style, code)
         return style(code) if style.nil? || style.plain?
 
@@ -387,8 +412,9 @@ module Calcsheet
         attributes.empty? ? nil : "<alignment #{attributes.join(" ")}/>"
       end
 
-      def write_header(columns)
-        style = style_attribute(HEADER_STYLE)
+      # The header row, bold or in +header_style+ (a Style).
+      def write_header(columns, header_style)
+        style = header_style ? cell_attribute(header_style, nil) : style_attribute(HEADER_STYLE)
         @buffer << '<row r="1">'
         columns.each_with_index do |column, index|
           @buffer << %(<c r="#{@letters[index]}1"#{style} t="inlineStr"><is><t xml:space="preserve">)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: calcsheet
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Demetra Opinioni.net Srl