fast_xlsx 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14314a7af34dfb1bfd00bac2f8fde41c4fa03447020dfef48571055bdac3151d
-  data.tar.gz: 915ca1cd79de28ca34023af4d884eb9c6728bd86abd29aa19bd62ca08e3914fe
+  metadata.gz: '045446748368a71ae4010c17da8b09d0a23ac2c3e9bdb0d63bf5ed54bf04221c'
+  data.tar.gz: 213cafbae07330020d41e179fc8473a92e5eab5da4cc595fb60e62f3764fa21e
 SHA512:
-  metadata.gz: 346ed04a149c9f6201fdb84af8b5b1a5a1008a17ac1df8faaa26af8d500dc2e13ecd8eb55705638a99a27501d7ca757f08a50825c7faac4a4a2593fb556a94e5
-  data.tar.gz: 712d24c13ab60499f91795cdbdd4d3c251e41c6b30b60dc8c9e3d25aaa671da98710d128dd673c859ad2ec336c817d69da6a46ea5e9f7a8015025444db59bcef
+  metadata.gz: dce10715e570fffa0c5ff69899065c07a3f34f6beb8a9597c095a39f271991d11f05239e62135d853063759a016518fca9f61113e0ae8991c97663a62b4066ff
+  data.tar.gz: d87800324af3edab7719ce665cb836d213456102833e04351cfdec508ef063e4c4b16aa80e298ab764262b6a4c6c97e8b2844b48b97639a3e005572369ecf2ce

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-01
+
+### Changed
+
+- Dates and times written without a format now get `yyyy-mm-dd` (`Date`) or `yyyy-mm-dd hh:mm:ss` (`Time`, `DateTime`) instead of showing as serial numbers. A cell's own format, its table column's and `column_format` still win. Applying the format makes writing date-heavy data about 15% slower, the same as passing a date format yourself.
+
 ## [0.3.0] - 2026-10-01
 
 ### Changed

data/README.md

@@ -82,6 +82,8 @@ ws.write(1, 2, Date.today, date)                         # format one cell
 
 Per-side borders override `border`. Unknown options and invalid values raise `ArgumentError`.
 
+Dates and times written without a format get `yyyy-mm-dd` or `yyyy-mm-dd hh:mm:ss`; a table column's format or `column_format` wins over that. A format you pass replaces it, so give date cells one with a `num_format` (e.g. `Format.new(bold: true, num_format: "yyyy-mm-dd")`), or Excel shows the serial number.
+
 ### Columns and filters
 
 ```ruby
@@ -250,8 +252,8 @@ Values are mapped by type:
 |---|---|
 | `Integer`, `Float`, any `Numeric` | number |
 | `String` | string |
-| `Time` | number (Excel serial date, local time) |
-| `Date`, `DateTime` | number (Excel serial date, own offset) |
+| `Time`, `DateTime` | date and time (`yyyy-mm-dd hh:mm:ss` unless formatted), in its own offset |
+| `Date` | date (`yyyy-mm-dd` unless formatted) |
 | `FastXlsx::Formula.new("SUM(A1:A9)")` | formula |
 | `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 |
@@ -273,17 +275,17 @@ Apple Silicon, Ruby 4.0.5. Each library uses its own idiomatic row-append API; x
 
 | Library | Time | vs fastest | Ruby objects allocated |
 |---|---:|---:|---:|
-| **fast_xlsx** (`memory: :constant`) | **69 ms** | 1.0x | 7 |
-| **fast_xlsx** (`memory: :low`) | **78 ms** | 1.1x | 7 |
-| **fast_xlsx** | **80 ms** | 1.2x | 10 |
-| [xlsxtream](https://github.com/felixbuenemann/xlsxtream) 3.1 | 171 ms | 2.5x | 561,728 |
-| [fast_excel](https://github.com/Paxa/fast_excel) 0.5 (constant_memory) | 194 ms | 2.8x | 20,079 |
-| [fast_excel](https://github.com/Paxa/fast_excel) 0.5 | 228 ms | 3.3x | 320,076 |
-| [write_xlsx](https://github.com/cxn03651/write_xlsx) 1.15 | 583 ms | 8.4x | 1,483,899 |
-| [caxlsx](https://github.com/caxlsx/caxlsx) 4.5 | 691 ms | 10.0x | 745,122 |
-| [rubyXL](https://github.com/weshatheleopard/rubyXL) 3.4 | 2650 ms | 38.3x | 8,700,448 |
-
-All outputs are 681–750 KB.
+| **fast_xlsx** (`memory: :constant`) | **77 ms** | 1.0x | 7 |
+| **fast_xlsx** (`memory: :low`) | **86 ms** | 1.1x | 7 |
+| **fast_xlsx** | **89 ms** | 1.1x | 10 |
+| [xlsxtream](https://github.com/felixbuenemann/xlsxtream) 3.1 | 183 ms | 2.4x | 561,728 |
+| [fast_excel](https://github.com/Paxa/fast_excel) 0.5 (constant_memory) | 200 ms | 2.6x | 20,079 |
+| [fast_excel](https://github.com/Paxa/fast_excel) 0.5 | 238 ms | 3.1x | 320,076 |
+| [write_xlsx](https://github.com/cxn03651/write_xlsx) 1.15 | 608 ms | 7.8x | 1,483,899 |
+| [caxlsx](https://github.com/caxlsx/caxlsx) 4.5 | 689 ms | 8.9x | 745,122 |
+| [rubyXL](https://github.com/weshatheleopard/rubyXL) 3.4 | 2755 ms | 35.6x | 8,700,448 |
+
+All outputs are 689–750 KB.
 
 ### Memory
 

data/bench/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    fast_xlsx (0.3.0)
+    fast_xlsx (0.4.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.3.0)
+  fast_xlsx (0.4.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

@@ -1,5 +1,6 @@
 use std::cell::{Cell, RefCell};
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::LazyLock;
 use std::sync::{Arc, Mutex};
 
 use magnus::{
@@ -112,6 +113,8 @@ struct Worksheet {
     table_formats: RefCell<Vec<TableColumnFormat>>,
     // Merged ranges as (first_row, first_col, last_row, last_col).
     merges: RefCell<Vec<(u32, u16, u32, u16)>>,
+    // Column ranges given a format with column_format.
+    formatted_columns: RefCell<Vec<(u16, u16)>>,
 }
 
 struct TableColumnFormat {
@@ -179,6 +182,7 @@ impl Workbook {
             flushes_rows: self.constant_memory || self.low_memory,
             table_formats: RefCell::new(Vec::new()),
             merges: RefCell::new(Vec::new()),
+            formatted_columns: RefCell::new(Vec::new()),
         })
     }
 
@@ -297,6 +301,8 @@ enum CellValue {
     Empty,
     Text(String),
     Number(f64),
+    // An Excel serial date; true when it has a time of day (Time, DateTime).
+    Date(f64, bool),
     Bool(bool),
     Formula(String),
     Url(String, Option<String>),
@@ -315,7 +321,7 @@ impl CellValue {
         } else if v.is_kind_of(ruby.class_numeric()) {
             CellValue::Number(f64::try_convert(v)?)
         } else if v.is_kind_of(ruby.class_time()) {
-            CellValue::Number(excel_time(v)?)
+            CellValue::Date(excel_time(v)?, true)
         } else if v.is_kind_of(ruby.class_true_class()) || v.is_kind_of(ruby.class_false_class()) {
             CellValue::Bool(v.to_bool())
         } else if v.is_kind_of(ruby.get_inner(&FORMULA)) {
@@ -333,7 +339,8 @@ impl CellValue {
             })?;
             CellValue::Rich(parts)
         } else if v.respond_to("jd", false)? {
-            CellValue::Number(excel_date(v)?)
+            // Date has no #hour; DateTime does.
+            CellValue::Date(excel_date(v)?, v.respond_to("hour", false)?)
         } else {
             CellValue::Text(v.funcall("to_s", ())?)
         };
@@ -341,6 +348,20 @@ impl CellValue {
         Ok(value)
     }
 
+    // The format for a value written without one: without a number format
+    // Excel shows a date as its serial number.
+    fn default_format(&self) -> Option<&'static rust_xlsxwriter::Format> {
+        static DATE: LazyLock<rust_xlsxwriter::Format> =
+            LazyLock::new(|| rust_xlsxwriter::Format::new().set_num_format("yyyy-mm-dd"));
+        static DATE_TIME: LazyLock<rust_xlsxwriter::Format> =
+            LazyLock::new(|| rust_xlsxwriter::Format::new().set_num_format("yyyy-mm-dd hh:mm:ss"));
+        match self {
+            CellValue::Date(_, false) => Some(&DATE),
+            CellValue::Date(_, true) => Some(&DATE_TIME),
+            _ => None,
+        }
+    }
+
     // Rejects what the writer would, so a row or merge fails before anything
     // is written. Numbers, booleans and formulas only fail on a bad row/column.
     fn check(&self) -> Result<(), Error> {
@@ -371,7 +392,7 @@ impl CellValue {
         match self {
             CellValue::Empty => Ok(()),
             CellValue::Text(s) => emit(ws, row, col, s.as_str(), format),
-            CellValue::Number(n) => emit(ws, row, col, *n, format),
+            CellValue::Number(n) | CellValue::Date(n, _) => emit(ws, row, col, *n, format),
             CellValue::Bool(b) => emit(ws, row, col, *b, format),
             CellValue::Formula(f) => emit(
                 ws,
@@ -950,6 +971,28 @@ impl Worksheet {
         })
     }
 
+    // The format a value is written with: its own, else its table column's,
+    // else its type's default (dates) unless column_format covers the column,
+    // whose format rust_xlsxwriter applies to cells written without one.
+    fn format_for<'a>(
+        &self,
+        tables: &'a [TableColumnFormat],
+        row: u32,
+        col: u16,
+        own: Option<&'a rust_xlsxwriter::Format>,
+        value: &CellValue,
+    ) -> Option<&'a rust_xlsxwriter::Format> {
+        Self::cell_format(tables, row, col, own).or_else(|| {
+            value.default_format().filter(|_| {
+                !self
+                    .formatted_columns
+                    .borrow()
+                    .iter()
+                    .any(|&(first, last)| (first..=last).contains(&col))
+            })
+        })
+    }
+
     fn write_row(
         &self,
         ruby: &Ruby,
@@ -976,7 +1019,7 @@ impl Worksheet {
             // 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::cell_format(&tables, row, *col, format.as_deref());
+                let format = self.format_for(&tables, row, *col, format.as_deref(), value);
                 value.write(ws, row, *col, format)?;
             }
             Ok(())
@@ -1025,7 +1068,7 @@ impl Worksheet {
                 ws,
                 row,
                 col,
-                Self::cell_format(&tables, row, col, format.map(|f| &*f.0)),
+                rb_self.format_for(&tables, row, col, format.map(|f| &*f.0), &value),
             )
         })?;
         rb_self.advance(row);
@@ -1070,7 +1113,9 @@ impl Worksheet {
             ws.set_column_range_format(first, last, &format.0)
                 .map(|_| ())
                 .map_err(xerr)
-        })
+        })?;
+        self.formatted_columns.borrow_mut().push((first, last));
+        Ok(())
     }
 
     fn autofilter(
@@ -1193,7 +1238,8 @@ impl Worksheet {
         }
         let value = CellValue::from_ruby(ruby, v)?;
         let tables = rb_self.table_formats.borrow();
-        let format = Self::cell_format(&tables, first_row, first_col, format.map(|f| &*f.0));
+        let format =
+            rb_self.format_for(&tables, first_row, first_col, format.map(|f| &*f.0), &value);
         let default = rust_xlsxwriter::Format::new();
         rb_self.with_ws(|ws| {
             // The value was checked when converted, so once the range is

data/lib/fast_xlsx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastXlsx
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

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