roo-oxide 0.0.2-x64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e1af8f92835d68f057b646dd72d8d44585c00be6121bd2768450bdbbc0b2156d
+  data.tar.gz: d86051eabbb82cd4137e3114fa3d7b90074ff9f6f3ecf7b668454d43083679ca
+SHA512:
+  metadata.gz: 98b9882d803e627badd20da08506ad6c19d4ebe5a9becde651bc933e7c8ec0405eff2530ff4f13dac481618f853d7391b1aad08c70812f3d9ac1e352903d32fd
+  data.tar.gz: 33ad164c32fbd2131a7618ee1159eaceedf0378ac36215c8147211aa680003b9e31c37bcb727250a58b49aafd44d8105872f27ce26f253d79cff86cfef1de459

data/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+## [0.0.2](https://github.com/salasebas/roo-oxide/compare/v0.0.1...v0.0.2) (2026-11-13)
+
+
+### Features
+
+* name the native Roo accelerator roo-oxide ([#78](https://github.com/salasebas/roo-oxide/issues/78)) ([6a67945](https://github.com/salasebas/roo-oxide/commit/6a6794599b3fe2ff3c68d11b82b0c78f9b812c1f))
+* read values 2x faster than streaming with an opt-in Roo::Calamine.each_row_values ([#12](https://github.com/salasebas/roo-oxide/issues/12)) ([c4d02de](https://github.com/salasebas/roo-oxide/commit/c4d02de37458641a9e24db0de0d3b5eef7da5927))
+
+
+### Performance Improvements
+
+* build cell coordinates in Rust for 3-13% faster reads ([#13](https://github.com/salasebas/roo-oxide/issues/13)) ([42a57f5](https://github.com/salasebas/roo-oxide/commit/42a57f5d044000fda04022e8de500d7fbb5deb53))
+* build cell coordinates in Rust instead of Coordinate.new ([42a57f5](https://github.com/salasebas/roo-oxide/commit/42a57f5d044000fda04022e8de500d7fbb5deb53))
+* build roo cells without running their Ruby constructors ([5f4561a](https://github.com/salasebas/roo-oxide/commit/5f4561a3821fc94f3c63c8eb1d3bfd273f7cffc7))
+* cut clean row iteration time by 62% ([#70](https://github.com/salasebas/roo-oxide/issues/70)) ([43914e9](https://github.com/salasebas/roo-oxide/commit/43914e90cc018ba07fcc29f92d3e2a866ab3eccb))
+* cut each_row_values peak memory by up to 30% by converting rows straight to values ([#23](https://github.com/salasebas/roo-oxide/issues/23)) ([82c2d69](https://github.com/salasebas/roo-oxide/commit/82c2d693b905df0d1aba4b195e930b898b92b34d))
+* cut IO workbook streaming memory by 53-58% ([#56](https://github.com/salasebas/roo-oxide/issues/56)) ([735e7b0](https://github.com/salasebas/roo-oxide/commit/735e7b00b6c8e335704492a5fdc5fa92d27312ed))
+* cut parse allocations by 200k and small cell lookup time by 20% ([#42](https://github.com/salasebas/roo-oxide/issues/42)) ([fdb6a93](https://github.com/salasebas/roo-oxide/commit/fdb6a9335d53d7c8117bce8d47b1e448dce81cf5))
+* cut peak memory 11–19% (65 MiB) on workbooks with many unique strings by extracting sharedStrings.xml natively ([#37](https://github.com/salasebas/roo-oxide/issues/37)) ([7722a73](https://github.com/salasebas/roo-oxide/commit/7722a733eef5ca146d6ea4d5639aaf36fe22d1f8))
+* cut peak memory of row, column, and cell reads by up to 26% with 20-byte native records ([#32](https://github.com/salasebas/roo-oxide/issues/32)) ([f165dc5](https://github.com/salasebas/roo-oxide/commit/f165dc5048e5061c9f5a05ba60256f0309670ee9))
+* cut row reads by parsing plain cells directly ([fd71931](https://github.com/salasebas/roo-oxide/commit/fd7193170749a7462e8450d131e501317aad5c9b))
+* cut small-workbook opening time by 37% ([#60](https://github.com/salasebas/roo-oxide/issues/60)) ([2cd40eb](https://github.com/salasebas/roo-oxide/commit/2cd40eb5e3c63839dcfdd9b28ca76567f21916ac))
+* cut temporal CSV and formatted read times by 46–66% ([#71](https://github.com/salasebas/roo-oxide/issues/71)) ([21f9da6](https://github.com/salasebas/roo-oxide/commit/21f9da66f1260eb41469f1b6ef57a98b8d57f871))
+* cut unique-string document reads by 25–42% ([#61](https://github.com/salasebas/roo-oxide/issues/61)) ([2660f9a](https://github.com/salasebas/roo-oxide/commit/2660f9a113800fdb6819cd6ecf77193f329227d2))
+* cut unique-string peak memory 23–43% by deferring HTML strings ([#44](https://github.com/salasebas/roo-oxide/issues/44)) ([7806c6f](https://github.com/salasebas/roo-oxide/commit/7806c6fe40f9f52e9aa048be186d4a79ec24016a))
+* export YAML, XML and Matrix 19–51× faster ([#58](https://github.com/salasebas/roo-oxide/issues/58)) ([e979933](https://github.com/salasebas/roo-oxide/commit/e979933c97338a768bc606d7b374f50621081481))
+* hand each_row_streaming the native row array directly ([bf37bc7](https://github.com/salasebas/roo-oxide/commit/bf37bc717c51f43f1b9a8745ff066f42673d55fd))
+* make each 8× faster on sparse sheets built whole by indexing their cells by row ([#30](https://github.com/salasebas/roo-oxide/issues/30)) ([f915c14](https://github.com/salasebas/roo-oxide/commit/f915c14ad69325988b7006627652ba736ca9738f))
+* make each and parse(headers: true) 2–2.6× faster with half the memory by reading rows from the native records ([#25](https://github.com/salasebas/roo-oxide/issues/25)) ([e5ae0a9](https://github.com/salasebas/roo-oxide/commit/e5ae0a91ab814e5aa6eb2cd70cd4e31fcfc34b87))
+* make each without options up to 47% faster on large sheets ([#18](https://github.com/salasebas/roo-oxide/issues/18)) ([739f02c](https://github.com/salasebas/roo-oxide/commit/739f02c5fed5f46c074a91776ba62180a75bc0d3))
+* make header iteration as fast as parse ([#57](https://github.com/salasebas/roo-oxide/issues/57)) ([03f8520](https://github.com/salasebas/roo-oxide/commit/03f8520a59ceb938a2f357ab2dad6a8fb0e27811))
+* make parse(headers: true) 2x faster by grouping the cells hash in one pass ([#14](https://github.com/salasebas/roo-oxide/issues/14)) ([1d15aae](https://github.com/salasebas/roo-oxide/commit/1d15aae5d0ef83413be288157f012e517c35e54f))
+* make single-cell reads 2x faster with 3x less memory by building cells lazily ([#17](https://github.com/salasebas/roo-oxide/issues/17)) ([c2417fb](https://github.com/salasebas/roo-oxide/commit/c2417fb3238d76da4fe30bd437ea95b2859bc604))
+* read columns 2.6–8.4× faster with half the memory from the native records ([#31](https://github.com/salasebas/roo-oxide/issues/31)) ([8b0b683](https://github.com/salasebas/roo-oxide/commit/8b0b683935b3ec7f78513f360221d4eb208a5638))
+* read hyperlinks and merged ranges natively instead of loading the whole sheet into Nokogiri ([29e5fd6](https://github.com/salasebas/roo-oxide/commit/29e5fd64ce4e1a36d11b5eee7a48fc75fa49e792))
+* read row values and random cells 30-40% faster by parsing each tag's attributes once ([#22](https://github.com/salasebas/roo-oxide/issues/22)) ([afd5ad1](https://github.com/salasebas/roo-oxide/commit/afd5ad13b88670eefa4647ce5b41e960d500b04f))
+* read sheets with hyperlinks or expanded merged ranges 30-60% faster in up to 20x less memory ([#26](https://github.com/salasebas/roo-oxide/issues/26)) ([29e5fd6](https://github.com/salasebas/roo-oxide/commit/29e5fd64ce4e1a36d11b5eee7a48fc75fa49e792))
+* read small workbook rows 8–13% faster with in-memory metadata ([#45](https://github.com/salasebas/roo-oxide/issues/45)) ([eb7c4e9](https://github.com/salasebas/roo-oxide/commit/eb7c4e92ee31f981a6ffeaf32b7528ddba40125e))
+* read small worksheets 11% faster natively with lazy ZIP inflation ([#43](https://github.com/salasebas/roo-oxide/issues/43)) ([65bd561](https://github.com/salasebas/roo-oxide/commit/65bd56137023b87c5e588ee6f9817191fe84f646))
+* read workbooks full of unique or rich-text strings 4-17x faster by parsing shared strings natively ([#27](https://github.com/salasebas/roo-oxide/issues/27)) ([de00e34](https://github.com/salasebas/roo-oxide/commit/de00e3429d3d6d8b2a4a76e7db6f5ea3d9520f52))
+* read worksheets from a copy of the xlsx instead of roo's extracted files ([77c232b](https://github.com/salasebas/roo-oxide/commit/77c232bfd736e85257782c767a48c73b6adec433))
+* read worksheets straight from a copy of the xlsx zip, with up to 60% less peak memory on large files ([#28](https://github.com/salasebas/roo-oxide/issues/28)) ([77c232b](https://github.com/salasebas/roo-oxide/commit/77c232bfd736e85257782c767a48c73b6adec433))
+* reduce Array row iteration overhead ([#59](https://github.com/salasebas/roo-oxide/issues/59)) ([5ab8230](https://github.com/salasebas/roo-oxide/commit/5ab823065464f9c38dbbe9f6f55b87e4ac5eb76f))
+* reduce native cell construction overhead ([c974479](https://github.com/salasebas/roo-oxide/commit/c9744797ca42b46787479195201a6863e32b6856))
+* reduce row-read overhead by parsing plain cells directly ([#69](https://github.com/salasebas/roo-oxide/issues/69)) ([fd71931](https://github.com/salasebas/roo-oxide/commit/fd7193170749a7462e8450d131e501317aad5c9b))
+* reduce single-cell read latency on small sheets ([#73](https://github.com/salasebas/roo-oxide/issues/73)) ([194b149](https://github.com/salasebas/roo-oxide/commit/194b149d64a2682fa43fc54319a640dfe4eb300e))
+* speed up each_row_values 7–9% and each, cell and parse 3–9% by reading common cell attributes on a fast path ([#36](https://github.com/salasebas/roo-oxide/issues/36)) ([d98ff8a](https://github.com/salasebas/roo-oxide/commit/d98ff8ac9ba96e30badab264e5e37a41029fe9cc))
+* speed up hyperlink reads and row iteration ([#72](https://github.com/salasebas/roo-oxide/issues/72)) ([4f47c26](https://github.com/salasebas/roo-oxide/commit/4f47c264ae9ead7f83dbc5e3c4596d53f3172b55))
+* speed up initial temporal scans 40–42% with 31–33% less memory ([#41](https://github.com/salasebas/roo-oxide/issues/41)) ([c974479](https://github.com/salasebas/roo-oxide/commit/c9744797ca42b46787479195201a6863e32b6856))
+* stream rows 7–18% faster by yielding the native row array without copying it ([#35](https://github.com/salasebas/roo-oxide/issues/35)) ([bf37bc7](https://github.com/salasebas/roo-oxide/commit/bf37bc717c51f43f1b9a8745ff066f42673d55fd))
+* stream tall sheets ~10% faster by handing Ruby one row at a time ([#24](https://github.com/salasebas/roo-oxide/issues/24)) ([4370a4b](https://github.com/salasebas/roo-oxide/commit/4370a4bac1656b01ff976b3815f9eb382101c83b))
+* stream xlsx 30% faster by building roo cells without their constructors ([#15](https://github.com/salasebas/roo-oxide/issues/15)) ([5f4561a](https://github.com/salasebas/roo-oxide/commit/5f4561a3821fc94f3c63c8eb1d3bfd273f7cffc7))
+* write to_csv 2–22× faster with byte-identical output by walking the cells once ([#29](https://github.com/salasebas/roo-oxide/issues/29)) ([2094b39](https://github.com/salasebas/roo-oxide/commit/2094b39d9259dd1787b457a4d4c6dff9df7e6cf1))
+* write to_csv 2.2–3.9× faster with up to 83% less peak memory from the native records ([#38](https://github.com/salasebas/roo-oxide/issues/38)) ([8293459](https://github.com/salasebas/roo-oxide/commit/829345998667a208d1c76abc26f4242f2c1a2bd8))
+
+## 0.0.1 (2026-11-10)
+
+
+### Features
+
+* make roo read xlsx files 4-12x faster with identical results ([#1](https://github.com/salasebas/roo-calamine/issues/1)) ([dce0aa4](https://github.com/salasebas/roo-calamine/commit/dce0aa4737b6e376ef01eb4f2aa8f602331d4d0b))

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sebastian Sala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,220 @@
+# roo-oxide
+
+Native acceleration for [Roo](https://github.com/roo-rb/roo), powered by Rust.
+
+roo-oxide is built on top of Roo and installs it as a dependency. It replaces
+Roo's busiest `.xlsx` and `.xlsm` read paths with a native engine, while you
+keep using `Roo::Spreadsheet`, `Roo::Excelx` and the same cell/value APIs.
+On the measured large sheets, reads are **16–36× faster** with **2–31× less
+memory**. Your existing Roo code stays the same.
+
+```ruby
+# Gemfile
+gem "roo-oxide"
+```
+
+```ruby
+xlsx = Roo::Spreadsheet.open("orders.xlsx") # or Roo::Excelx.new("orders.xlsx")
+xlsx.each_row_streaming { |row| ... }        # read by the native reader
+xlsx.parse(headers: true)                    # this too
+```
+
+> **Unofficial.** roo-oxide is not affiliated with or endorsed by roo-rb or
+> the roo maintainers.
+
+## Install
+
+Add only `gem "roo-oxide"` to your Gemfile. Bundler installs Roo automatically
+and loads the acceleration layer on `Bundler.require` (as Rails does).
+Without Bundler, install `roo-oxide` and `require "roo/oxide"`; it loads Roo
+for you.
+
+### Migrating from roo-calamine
+
+Replace `gem "roo-calamine"` with `gem "roo-oxide"`. Roo is installed as a
+dependency, so a separate `gem "roo"` line is optional.
+Use `require "roo/oxide"` and `Roo::Oxide` in new code. The old
+`require "roo/calamine"`, version require and `Roo::Calamine` constant remain
+available as compatibility aliases in the new gem. Load one plugin gem at a
+time; loading the old plugin before roo-oxide raises a migration error.
+
+`ROO_CALAMINE` still works when `ROO_OXIDE` is unset. When both are set,
+`ROO_OXIDE` takes precedence.
+
+| | |
+|---|---|
+| Ruby | CRuby 3.3, 3.4, 4.0 |
+| roo | `~> 4.0` |
+| Precompiled | Linux x86_64/aarch64 (glibc, musl), macOS x86_64/arm64, Windows x64 |
+| Other platforms | the source gem compiles with Rust 1.86 or later |
+| JRuby | installs without Rust and stays inert: roo reads every file itself |
+
+## Benchmarks
+
+100,000 rows × 20 mixed columns, Apple M5 Pro, Ruby 3.4.12. Time and peak
+memory include opening the workbook.
+
+| | roo 4.0.0 | roo + roo-oxide | Faster |
+|---|---:|---:|---:|
+| `each_row_streaming` | 13.49 s · 119 MB | **0.59 s · 51 MB** | 23× |
+| `parse(headers: true)` | 19.61 s · 3300 MB | **0.75 s · 282 MB** | 26× |
+| `each` | 18.81 s · 3282 MB | **0.62 s · 174 MB** | 30× |
+| 10,000 random `cell(row, col)` | 17.25 s · 3272 MB | **0.48 s · 104 MB** | 36× |
+| `to_csv` | 21.72 s · 3369 MB | **0.77 s · 118 MB** | 28× |
+| `to_yaml` | 24.26 s · 3430 MB | **1.28 s · 322 MB** | 19× |
+| `to_xml` | 50.81 s · 3991 MB | **1.04 s · 711 MB** | 49× |
+| `to_matrix` | 19.97 s · 3287 MB | **0.65 s · 216 MB** | 31× |
+| [`each_row_values`](#values-only) | 13.43 s · 118 MB | **0.44 s · 47 MB** | 31× |
+
+On the other test files it is 18–43× faster with shared strings, 16–33× with
+unique strings, and 2.6–10× on a 100-row sheet. See
+[bench/README.md](bench/README.md) for every file, the method, and how to run
+it. [bench/RESULTS.md](bench/RESULTS.md) times every public roo read. It
+ties roo only where roo reads the file itself: CSV, and XML roo-oxide
+hands back.
+
+## Values only
+
+If you only need values, `Roo::Oxide.each_row_values` skips roo's cell
+objects. It is roo-oxide's own API, not roo's, and using it changes nothing
+in what roo does.
+
+```ruby
+Roo::Oxide.each_row_values("orders.xlsx", sheet: "Orders") do |values|
+  values # => [1001, "Ada", #<Date: 2024-05-01>, 19.5, nil, true]
+end
+```
+
+Each row equals, value for value, what this roo code yields:
+
+```ruby
+Roo::Excelx.new("orders.xlsx").each_row_streaming(sheet: "Orders", pad_cells: true) do |cells|
+  cells.map { |cell| cell&.value }
+end
+```
+
+<details>
+<summary>Arguments and value rules</summary>
+
+- **Arguments:** a path or an IO; `sheet:` is a name or index (default: the
+  first sheet); other keywords are `Roo::Excelx.new` options.
+- **Return:** an Enumerator without a block. It closes the workbook when it is
+  done.
+- **Rows:** one entry per column from A to the row's last cell, with `nil`
+  where there is no cell.
+- **Values** follow roo's rules: Integer or Float by the written text and
+  number format; Date, DateTime and Time by the style; roo's shared strings
+  (HTML for rich text); `Roo::Link` for hyperlinks; error text such as
+  `"#DIV/0!"`.
+- With the reader off, or on JRuby, it reads through roo and yields the same
+  rows.
+
+</details>
+
+## Turning it off
+
+```ruby
+Roo::Oxide.enabled = false # from the next sheet read on
+```
+
+```sh
+ROO_OXIDE=0 bundle exec rails server # also: false, off
+```
+
+Either one makes roo read exactly as it does without the gem.
+`Roo::Oxide.enabled?` tells whether the next read uses the native reader,
+and `Roo::Oxide.available?` whether the extension is loaded.
+
+## How it works
+
+roo-oxide prepends modules to roo's classes. A read such as
+`each_row_streaming` reaches roo-oxide first, which either does the work in
+a Rust extension and returns the objects roo would return, or hands the call
+back to roo.
+
+- **Opening:** worksheets stay in the zip until they are read.
+- **Parsing:** worksheet XML is streamed with
+  [quick-xml](https://github.com/tafia/quick-xml) instead of loaded into a
+  Nokogiri document.
+- **Lazy cells:** the sheet lives in compact native records, and a
+  `Roo::Excelx::Cell` is built only when something reads it.
+- **Output:** `to_csv`, `to_yaml`, `to_xml`, and `to_matrix` are written from
+  those records.
+- **Fallback:** XML the reader cannot reproduce exactly the way Nokogiri does
+  goes back to roo.
+
+Styles, number formats, comments, images, and every open option stay roo's
+code. roo is the test oracle: roo 4.0.0's own suite, every roo fixture, and the
+edge-case suites must give the same results with and without roo-oxide.
+[docs/how-it-works.md](docs/how-it-works.md) has the details and the test
+coverage.
+
+### Known differences
+
+These are by design.
+
+<details>
+<summary>Overrides of roo's private methods</summary>
+
+- Under roo 4.0.0, overrides of roo's private shared-string parsing
+  (`SharedStrings#extract_shared_strings`, `#extract_html`,
+  `#fix_invalid_shared_strings`, `#create_html`) are bypassed while the reader
+  is on. Other roo versions build their shared strings themselves.
+- Overrides of roo's private cell parsing (`SheetDoc#cell_from_xml`,
+  `#extract_cells`, `#extract_hyperlinks`, `#expand_merged_ranges`,
+  `Cell.cell_class`) are bypassed while the reader is on. So are:
+  - a `Roo::Excelx` subclass's `#cell` or `#each` inside `parse` and `each`
+    with options;
+  - its `#cell`, `#celltype`, `#empty?`, or roo's private `#cell_to_csv`
+    inside `to_csv`;
+  - redefinitions of the
+    [single-cell reads](docs/how-it-works.md#cells-and-values) in `Roo::Excelx`
+    or `Roo::Excelx::Sheet` themselves (subclasses work);
+  - under roo 4.0.0, an override of `initialize` on a `Cell` class or on
+    `Roo::Excelx::Coordinate`;
+  - under roo 4.0.0, `Sheet#pad_cells` redefined in `Roo::Excelx::Sheet`
+    itself (subclasses and prepended overrides work).
+
+</details>
+
+<details>
+<summary>Behavior and performance</summary>
+
+- **Building `Sheet#cells` late costs more.** Building the whole hash (`#set`,
+  for example) after a read that does not need it (a single-cell read,
+  `#last_row`, `#row`, `#each`, `#parse`) costs more than building it from the
+  start, because the sheet is parsed before any cell is built rather than
+  alongside.
+- **Non-UTF-8 text set by hand.** A cell value set to non-ASCII text in an
+  encoding other than UTF-8 can make `to_csv` raise
+  `Encoding::CompatibilityError`, where roo writes it, when its line also
+  holds non-ASCII UTF-8 text. Cells read from a file are always UTF-8.
+- **Writes straight into `cells`.** On a
+  [sheet built whole](docs/how-it-works.md#cells-and-values), inside an `each`
+  block without options, a write straight into `sheet_for(...).cells` (not
+  through `set`) does not show in later rows.
+- **Broken XML.** On XML that breaks partway, `each_row_streaming` raises the
+  same `Nokogiri::XML::SyntaxError` as roo but yields a few more rows before
+  it.
+- **Errors come when a sheet is read.** A workbook leaves its worksheets in
+  the zip, so a worksheet whose compressed data is broken, or larger than the
+  zip says, raises roo's error when it is read rather than in
+  `Roo::Excelx.new`. The paths in `#sheet_files` exist only once roo's own
+  code has read them.
+
+</details>
+
+## Development
+
+```sh
+bundle install
+bundle exec rake compile   # build the extension
+bundle exec rake test      # unit, fixture, and edge-case tests
+bundle exec rake parity    # roo 4.0.0's own suites, with and without roo-oxide
+bundle exec rubocop
+cargo test && cargo clippy --all-targets -- -D warnings && cargo fmt --check
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/lib/roo/calamine/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "../oxide/version"
+
+Roo::Calamine = Roo::Oxide unless Roo.const_defined?(:Calamine, false)

data/lib/roo/calamine.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "oxide"

data/lib/roo/oxide/context.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # The answers the native reader needs from roo while it builds cells. Each
+    # one comes from the roo object or method that SheetDoc#cell_from_xml uses,
+    # so formats, shared strings, and errors are roo's own.
+    class Context
+      # roo versions whose cell constructors the native reader reproduces:
+      # under them it sets each cell's instance variables itself, and under
+      # any other version it calls the constructors.
+      CELL_LAYOUT_ROO_VERSIONS = %w[4.0.0].freeze
+
+      attr_reader :hyperlinks, :empty_cell
+
+      def initialize(shared, hyperlinks, empty_cell)
+        @shared = shared
+        @hyperlinks = hyperlinks
+        @empty_cell = empty_cell
+      end
+
+      def base_date
+        @shared.base_date
+      end
+
+      def base_timestamp
+        @shared.base_timestamp
+      end
+
+      def build_cells?
+        CELL_LAYOUT_ROO_VERSIONS.include?(Roo::VERSION)
+      end
+
+      # The format string, its type, and whether Cell::Number#create_numeric
+      # always calls Float under it (nil when matching it raises).
+      def style(index)
+        format = @shared.styles.style_format(index)
+        [format.to_s, Roo::Excelx::Format.to_type(format), float_format(format.to_s)]
+      end
+
+      def style_index(text)
+        text.to_i
+      end
+
+      def coordinate(reference)
+        Roo::Utils.extract_coordinate(reference)
+      end
+
+      # Roo's plain strings and deferred or public HTML table, nil when disabled.
+      def shared_strings
+        strings = @shared.shared_strings
+        html_disabled = strings.instance_variable_get(:@options)[:disable_html_wrapper]
+        plain = strings.to_a
+        [plain, (strings.oxide_html unless html_disabled)]
+      end
+
+      def shared_string(text)
+        shared_string_at(@shared.shared_strings, text.to_i)
+      end
+
+      private
+
+      def float_format(format)
+        format.match?(/%|\.0/)
+      rescue ArgumentError, EncodingError
+        nil
+      end
+
+      def shared_string_at(strings, index)
+        strings.use_html?(index) ? strings.to_html[index] : strings[index]
+      end
+    end
+  end
+end

data/lib/roo/oxide/csv.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Roo
+  module Oxide
+    # Prepended to Roo::Excelx. roo's #to_csv writes every slot from the first
+    # row and column to the last through #empty?, #cell and #celltype, and each
+    # of them looks up the sheet and the cell again. This writes the same text
+    # from one pass over the sheet's cells: natively from the lazy cells while
+    # the sheet has them, else a line at a time, asking each cell what roo's
+    # Roo::Formatters::CSV#cell_to_csv asks it, in the same order.
+    module CSV
+      # roo versions whose Roo::Formatters::CSV this reproduces. Under any other
+      # version roo writes the CSV itself.
+      ROO_VERSIONS = %w[4.0.0].freeze
+      private_constant :ROO_VERSIONS
+
+      private
+
+      def write_csv_content(file = nil, sheet = nil, separator = ",")
+        return super unless csv_lines?(separator.to_s)
+
+        file ||= STDOUT # rubocop:disable Style/GlobalStdStream
+        return unless first_row(sheet)
+
+        target = sheet_for(sheet)
+        area = [last_row(sheet), last_column(sheet), target.first_row, target.last_row, target.first_column,
+                target.last_column]
+        store = target.lazy_cells
+        if store && area.all?(Integer)
+          store.write_csv(file, self, separator.to_s, area)
+        else
+          write_csv_lines(file, target, separator.to_s, *area.first(2))
+        end
+      end
+
+      # roo prints each field on its own; a line joins them, so the separator
+      # has to join UTF-8 text, and IO#print must add no $\ between fields.
+      def csv_lines?(separator)
+        Oxide.enabled? && ROO_VERSIONS.include?(Roo::VERSION) && $OUTPUT_RECORD_SEPARATOR.nil? &&
+          (separator.ascii_only? || separator.encoding == Encoding::UTF_8)
+      end
+
+      # roo writes rows 1..last_row and columns 1..last_column, and prints the
+      # separator before every column but the first, then the field, so after
+      # a field raises the file holds the line up to it.
+      def write_csv_lines(file, sheet, separator, rows, width) # rubocop:disable Metrics
+        first_row = sheet.first_row
+        last_row = sheet.last_row
+        first_column = sheet.first_column
+        last_column = sheet.last_column
+        separators = Hash.new { |runs, count| runs[count] = separator * count }
+        blank_line = "#{separators[[width - 1, 0].max]}\n"
+        line = +""
+        line_row = written = 0
+        each_csv_cell(sheet.cells, rows, width) do |row, column, cell|
+          if row != line_row
+            file.print(line << separators[width - 1 - written] << "\n") if line_row.positive?
+            (row - line_row - 1).times { file.print(blank_line) }
+            line.clear
+            line_row = row
+            written = 0
+          end
+          line << separators[column - 1 - written]
+          written = column - 1
+          begin
+            next if !cell || cell.empty? || row < first_row || row > last_row ||
+                    column < first_column || column > last_column
+
+            line << csv_field(cell)
+          rescue StandardError
+            file.print(line)
+            raise
+          end
+        end
+        file.print(line << separators[width - 1 - written] << "\n") if line_row.positive?
+        (line_row + 1).upto(rows) { file.print(blank_line) }
+      end
+
+      # Yields the cells roo visits, by row and then column: those with an
+      # Integer row in 1..rows and an Integer column in 1..columns.
+      def each_csv_cell(cells, rows, columns)
+        if csv_keys_sorted?(cells)
+          cells.each_pair do |(row, column), cell|
+            break if row > rows
+
+            yield row, column, cell if row.positive? && column.between?(1, columns)
+          end
+        else
+          sorted_csv_keys(cells, rows, columns).each { |key| yield key[0], key[1], cells[key] }
+        end
+      end
+
+      def sorted_csv_keys(cells, rows, columns)
+        keys = cells.keys.select do |key|
+          key.is_a?(Array) && key.size == 2 && key.all?(Integer) &&
+            key[0].between?(1, rows) && key[1].between?(1, columns)
+        end
+        keys.sort!
+      end
+
+      # Whether every key is a [row, column] of Integers, in increasing order
+      # from row 0.
+      def csv_keys_sorted?(cells) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        previous_row = previous_column = 0
+        cells.each_key do |key|
+          return false unless key.is_a?(Array) && key.size == 2
+
+          row, column = key
+          return false unless row.is_a?(Integer) && column.is_a?(Integer)
+
+          if row == previous_row
+            return false if column < previous_column
+          elsif row < previous_row
+            return false
+          end
+          previous_row = row
+          previous_column = column
+        end
+        true
+      end
+
+      # Roo::Formatters::CSV#cell_to_csv after its #empty? check.
+      def csv_field(cell) # rubocop:disable Metrics/CyclomaticComplexity
+        value = cell.value
+        case (type = cell.type)
+        when :string then csv_quote(value) unless value.empty?
+        when :boolean then %("#{cell.formatted_value.gsub('"', '""').downcase}")
+        when :float, :percentage then csv_number(value)
+        when :formula then csv_formula_value(value)
+        when :date, :datetime then value.to_s
+        when :time then integer_to_timestring(value)
+        when :link then csv_quote(value.url)
+        else raise "unhandled celltype #{type}"
+        end || ""
+      end
+
+      def csv_formula_value(value)
+        case value
+        when String then csv_quote(value) unless value.empty?
+        when Integer, Date, DateTime, TrueClass, FalseClass then value.to_s
+        when Float then csv_number(value)
+        else raise "unhandled onecell-class #{value.class}"
+        end
+      end
+
+      def csv_quote(text)
+        text.include?('"') ? %("#{text.gsub('"', '""')}") : %("#{text}")
+      end
+
+      def csv_number(value)
+        value == value.to_i ? value.to_i.to_s : value.to_s
+      end
+    end
+  end
+end