roo-oxide 0.0.2

data/lib/roo/oxide/formatters.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Roo 4.0.0's output formatting, using the native records while the
+    # sheet's public cells hash has not been materialized.
+    module Formatters
+      def formatted_value(row, col, sheet = nil)
+        row, col = normalize(row, col) if row.is_a?(String) || col.is_a?(String)
+        cell = sheet_for(sheet).cell_at(row, col)
+        return formatter_temporal_value(cell) if native_formatters? && cell.is_a?(Roo::Excelx::Cell::DateTime)
+
+        cell.formatted_value if cell.respond_to?(:formatted_value)
+      end
+
+      def to_yaml(prefix = {}, from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet) # rubocop:disable Metrics/ParameterLists
+        return super unless native_formatters?
+        return "" unless first_row
+
+        area = formatter_area(sheet, [from_row, from_column, to_row, to_column])
+        store = sheet_for(sheet).lazy_cells
+        return super unless store && area.all?(Integer)
+
+        store.to_yaml(self, prefix, area)
+      end
+
+      def to_matrix(from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet) # rubocop:disable Metrics/ParameterLists
+        return super unless native_formatters?
+
+        require "matrix"
+        return ::Matrix.empty unless first_row
+
+        area = formatter_rectangle(sheet, [from_row, from_column, to_row, to_column])
+        store = sheet_for(sheet).lazy_cells
+        return super unless store && area.all?(Integer)
+
+        ::Matrix.rows(store.matrix_rows(area))
+      end
+
+      def to_xml
+        return super unless native_formatters?
+        return super if sheets.empty?
+
+        targets = sheets.map { |name| sheet_for(name) }
+        return super unless targets.all?(&:lazy_cells)
+
+        result = +"<?xml version=\"1.0\"?>\n<spreadsheet>\n"
+        document = Nokogiri::XML::Document.new
+        sheets.zip(targets).each do |name, target|
+          self.default_sheet = name
+          result << formatter_xml_sheet(document, name, target)
+        end
+        result << "</spreadsheet>\n"
+      end
+
+      private
+
+      def formatter_temporal_value(cell)
+        if cell.is_a?(Roo::Excelx::Cell::Time)
+          @oxide_time_formats ||= Hash.new { |formats, encoding| formats[encoding] = {} }
+          formatter = @oxide_time_formats[cell.format.encoding][cell.format] ||=
+            cell.format.gsub(/#{Roo::Excelx::Cell::DateTime::TIME_FORMATS.keys.join("|")}/,
+                             Roo::Excelx::Cell::DateTime::TIME_FORMATS)
+          return cell.instance_variable_get(:@datetime).strftime(formatter)
+        end
+
+        @oxide_datetime_formats ||= Hash.new { |formats, encoding| formats[encoding] = {} }
+        formatter = @oxide_datetime_formats[cell.format.encoding][cell.format] ||= formatter_datetime(cell)
+        formatter ? cell.value.strftime(formatter) : cell.formatted_value
+      end
+
+      def formatter_datetime(cell)
+        parts = cell.format.downcase.split(" ", 0).map do |part|
+          parsed = cell.send(:parse_date_or_time_format, part)
+          return nil unless parsed
+
+          parsed
+        end
+        parts.join(" ")
+      end
+
+      def native_formatters?
+        Oxide.enabled? && Roo::VERSION == "4.0.0"
+      end
+
+      def formatter_area(sheet, rectangle)
+        target = sheet_for(sheet)
+        formatter_rectangle(sheet, rectangle) +
+          [target.first_row, target.first_column, target.last_row, target.last_column]
+      end
+
+      def formatter_rectangle(sheet, rectangle)
+        bounds = %i[first_row first_column last_row last_column]
+        rectangle.zip(bounds).map { |requested, bound| requested || public_send(bound, sheet) }
+      end
+
+      def formatter_xml_sheet(document, name, target)
+        element = document.create_element("sheet", name:)
+        cells = first_row ? target.lazy_cells.xml_cells(self, formatter_area(name, [nil] * 4)) : ""
+        "  #{element.to_xml.delete_suffix("/>")}#{cells.empty? ? "/>\n" : ">\n#{cells}  </sheet>\n"}"
+      end
+
+      def formatter_yaml_prefix(prefix)
+        text = +""
+        prefix.each { |key, value| text << "  #{key}: #{value} \n" }
+        text
+      end
+
+      def formatter_xml_cell(value, row, column, type)
+        Nokogiri::XML::Document.new.create_element("cell", value, row:, column:, type:).to_xml
+      end
+    end
+  end
+end

data/lib/roo/oxide/row_index.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Answers Excelx#row for the default sheet from its cells in
+    # first_row..last_row and first_column..last_column, laid out in one pass
+    # over Sheet#cells: in one flat Array with a slot per column of each row
+    # (an Array per row costs a major GC on a large sheet), or, on a sheet
+    # with fewer than one cell per MAX_SLOTS_PER_CELL slots, in a Hash of an
+    # Array per row of its column offsets and cells. roo answers the first ROO_ROWS
+    # requests, so a caller that stops early never pays for that pass, and
+    # any other row, a sheet too short to repay the pass (fewer than
+    # 3 * ROO_ROWS rows), an empty sheet, and every request once the default
+    # sheet changes or Excelx#set writes to the workbook.
+    class RowIndex
+      ROO_ROWS = 1_000
+      MAX_SLOTS_PER_CELL = 4
+
+      def initialize(workbook)
+        @workbook = workbook
+        @requests = 0
+      end
+
+      def row(line, set_calls)
+        index = index(line) if current?(set_calls)
+        return @workbook.row(line) unless index
+
+        @lines ? sparse_row(@lines[index]) : @cells[index * @width, @width].map! { |cell| cell&.value }
+      end
+
+      private
+
+      def index(line)
+        line - @first_row if line.is_a?(Integer) && line.between?(@first_row, @last_row)
+      end
+
+      def current?(set_calls)
+        return false if (@requests += 1) <= ROO_ROWS
+
+        sheet = @workbook.sheet_for(nil)
+        build(sheet, set_calls) unless @sheet
+        (@cells || @lines) && @sheet.equal?(sheet) && @set_calls == set_calls
+      end
+
+      def sparse_row(entries)
+        values = Array.new(@width)
+        return values unless entries
+
+        i = 0
+        while i < entries.size
+          values[entries[i]] = entries[i + 1]&.value
+          i += 2
+        end
+        values
+      end
+
+      def build(sheet, set_calls)
+        @sheet = sheet
+        @set_calls = set_calls
+        return unless sheet.first_row && sheet.last_row >= 3 * ROO_ROWS
+
+        @first_row = sheet.first_row
+        @last_row = sheet.last_row
+        @first = sheet.first_column
+        @last = sheet.last_column
+        @width = @last - @first + 1
+        lay_out(sheet.cells, @last_row - @first_row + 1)
+      end
+
+      def lay_out(cells, rows)
+        if rows * @width > MAX_SLOTS_PER_CELL * cells.size
+          @lines = {}
+          each_cell(cells) { |index, column, cell| (@lines[index] ||= []).push(column, cell) }
+        else
+          @cells = Array.new(rows * @width)
+          each_cell(cells) { |index, column, cell| @cells[(index * @width) + column] = cell }
+        end
+      end
+
+      def each_cell(cells) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        cells.each_pair do |key, cell|
+          next unless key.is_a?(Array) && key.size == 2
+
+          line, column = key
+          next unless line.is_a?(Integer) && column.is_a?(Integer) &&
+                      line >= @first_row && line <= @last_row && column >= @first && column <= @last
+
+          yield line - @first_row, column - @first, cell
+        end
+      end
+    end
+  end
+end

data/lib/roo/oxide/row_iteration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Roo::Base#each reads the current sheet's row after every block call.
+    module Excelx
+      private
+
+      def native_rows?
+        Oxide.enabled? && method(:row).owner.equal?(::Roo::Excelx)
+      end
+
+      def each_without_options(&)
+        sheet = sheet_for(nil)
+        lazy = sheet.lazy_cells
+        return each_lazy_row(sheet, lazy, &) if lazy && sheet.first_column
+
+        index = RowIndex.new(self)
+        1.upto(last_row) { |line| yield index.row(line, @oxide_set_calls) }
+      end
+
+      def each_lazy_row(sheet, lazy)
+        last = last_row
+        line = lazy.each_row(last, sheet.first_column, sheet.last_column) do |values|
+          yield values
+          sheet_for(nil).equal?(sheet) && sheet.lazy_cells.equal?(lazy)
+        end
+        line.upto(last) { |number| yield row(number) }
+        1
+      end
+    end
+  end
+end

data/lib/roo/oxide/shared_strings.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Prepended to Roo::Excelx::SharedStrings: the native extension builds the
+    # arrays #to_a and #to_html memoize, deferring HTML objects until used.
+    # Roo's own code and the native reader share them. A file the extension
+    # does not read exactly the way roo does is left to roo.
+    module SharedStrings
+      # roo versions whose shared-string extraction the extension reproduces.
+      ROO_VERSIONS = %w[4.0.0].freeze
+
+      def to_a
+        oxide_read(html: !@options[:disable_html_wrapper] && !(@html || @oxide_html), plain: true) unless @array
+        super
+      end
+
+      def to_html
+        unless @html
+          oxide_read(html: true, plain: false) unless @oxide_html
+          @html = @oxide_html.to_a if @oxide_html && (@oxide_html_used || doc_exists?)
+        end
+        super
+      end
+
+      def oxide_html
+        return to_html unless @oxide_html && (@oxide_html_used || doc_exists?)
+
+        @oxide_html_used = true
+        @html || @oxide_html
+      end
+
+      private
+
+      def oxide_read(html:, plain:)
+        return unless Oxide.enabled? && ROO_VERSIONS.include?(Roo::VERSION) && doc_exists?
+
+        plain, html = Native.shared_strings(@path, html, plain)
+        @array ||= plain
+        @oxide_html ||= html
+      rescue UnsupportedError
+        nil
+      end
+    end
+  end
+end

data/lib/roo/oxide/sheet.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Prepended to Roo::Excelx::Sheet: single-cell lookups, rows, columns, and
+    # the sheet's bounds read the lazy cells of SheetDoc#lazy_cells while
+    # #cells has not been built, so they build only the cells they read. Rows
+    # and columns build only the cells whose value needs one.
+    module Sheet
+      NO_CELLS = [].freeze
+      private_constant :NO_CELLS
+
+      # cells[[row, column]]
+      def cell_at(row, column)
+        (lazy = lazy_cells) ? lazy.cell_at(row, column) : cells[[row, column]]
+      end
+
+      def row(row_number)
+        lazy = lazy_cells
+        return lazy.row(row_number, first_column, last_column) if lazy && first_column
+
+        first_column.upto(last_column).map do |col|
+          cell_at(row_number, col)&.value
+        end
+      end
+
+      def column(col_number)
+        lazy = lazy_cells
+        return lazy.column(col_number, first_row, last_row) if lazy && first_row
+
+        first_row.upto(last_row).map do |row|
+          cell_at(row, col_number)&.value
+        end
+      end
+
+      def excelx_format(key)
+        cell = (lazy = lazy_cells) ? lazy[key] : cells[key]
+        styles.style_format(cell.style).to_s if cell
+      end
+
+      # For Excelx#parse: a Hash per line of `lines`, holding the value of the
+      # cell at [line, column] under `key` for each [key, column] of `fields`.
+      def parse_rows(lines, fields)
+        lazy = lazy_cells
+        if lazy && fields.all? { |_, column| column.is_a?(Integer) }
+          lazy_parse_rows(lazy, lines, fields)
+        else
+          cells_parse_rows(lines, fields)
+        end
+      end
+
+      # The Native::Store behind the lazy cells while #cells is not built.
+      def lazy_cells
+        @sheet.lazy_cells(@rels) unless @cells
+      end
+
+      private
+
+      def lazy_parse_rows(lazy, lines, fields)
+        first, last = fields.map(&:last).minmax
+        slots = fields.map { |key, column| [key, column - first] }.freeze
+        lines.map { |line| lazy.hash_row(line, first || 1, last || 0, slots) }
+      end
+
+      def cells_parse_rows(lines, fields)
+        slots = fields.map(&:last).uniq.each_with_index.to_h
+        by_line = cells_by_line(slots)
+        fields = fields.map { |key, column| [key, slots.fetch(column)] }
+        lines.map do |line|
+          line_cells = by_line.fetch(line, NO_CELLS)
+          fields.each_with_object({}) do |(key, slot), row|
+            cell = line_cells[slot]
+            row[key] = (cell.value if cell.respond_to?(:value)) # Roo::Excelx#safe_send, inline
+          end
+        end
+      end
+
+      def cells_by_line(slots)
+        by_line = {}
+        cells.each do |(line, column), cell|
+          slot = slots[column] or next
+          (by_line[line] ||= Array.new(slots.size))[slot] = cell
+        end
+        by_line
+      end
+
+      # Custom padding stays in roo's loop over #each_cell.
+      def cells_for_row_element(row_element, options = {})
+        return super if options[:pad_cells] && !method(:pad_cells).owner.equal?(::Roo::Excelx::Sheet)
+
+        @sheet.native_row_cells(row_element, pad_cells: options[:pad_cells]) || super
+      end
+
+      def first_last_row_col
+        @first_last_row_col ||= lazy_cells&.bounds || super
+      end
+    end
+  end
+end

data/lib/roo/oxide/sheet_doc.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Prepended to Roo::Excelx::SheetDoc, where every worksheet read in roo
+    # starts: Sheet#cells (and with it #row, #each, #parse), the lazy cells
+    # behind Excelx#cell and the other single-cell lookups, and Sheet#each_row
+    # (#each_row_streaming). Offsets and row limits stay roo's code.
+    module SheetDoc
+      # Cells the native reader parses ahead of Ruby, per batch.
+      BATCH_CELLS = 16_384
+
+      # A sheet already read into a Native::Store is built from it even when
+      # the native reader has been turned off since, so the cells handed out
+      # stay the ones #cells holds.
+      def cells(relationships)
+        return super if @cells || !(native? || @oxide_store)
+
+        store = @oxide_store || nil
+        @oxide_store = nil
+        @cells = store ? store.cells : read_cells(relationships)
+      rescue UnsupportedError
+        super
+      end
+
+      # The cells of #cells, each built when it is first read. nil when they
+      # have to be built all at once: when #cells already exists, when merged
+      # ranges are expanded, and when building some cell would raise, because
+      # roo raises for the whole sheet then.
+      def lazy_cells(relationships)
+        if @oxide_store.nil? && !@cells && !@options[:expand_merged_ranges] && native?
+          @oxide_store = read_store(relationships)
+        end
+        @oxide_store || nil
+      end
+
+      # Yields Native::Row objects; #each_cell turns one into cells when roo
+      # asks for it, so rows roo skips are never converted, as in roo.
+      def each_row_streaming(&)
+        return super unless native?
+
+        yielded = 0
+        reader = Native::Reader.new(sheet_source, true, BATCH_CELLS)
+        while (row = reader.next_row)
+          yield row
+          yielded += 1
+        end
+        nil
+      rescue UnsupportedError
+        # roo reads the sheet again; skip the rows already yielded.
+        skip = yielded
+        super { |row| skip.zero? ? yield(row) : skip -= 1 }
+      ensure
+        # Also when the caller stops early, as roo does for max_rows.
+        reader&.close
+      end
+
+      def each_cell(row_xml, &)
+        return super unless row_xml.is_a?(Native::Row)
+
+        oxide_stream_converter.row_cells(row_xml, false).each(&)
+      end
+
+      # The cells #each_cell yields for a Native::Row, as a new Array; nil for
+      # rows roo reads itself, custom #each_cell, or roo-only padding.
+      def native_row_cells(row, pad_cells: false)
+        return unless row.is_a?(Native::Row) && method(:each_cell).owner.equal?(SheetDoc)
+
+        oxide_stream_converter.row_cells(row, pad_cells)
+      end
+
+      # Roo::Oxide.each_row_values. `sheet` is the Roo::Excelx::Sheet that
+      # owns this document; it turns rows that roo reads itself into cells.
+      def each_row_values(sheet, &)
+        return each_roo_row_values(sheet, 0, &) unless native?
+
+        yielded = 0
+        reader = Native::Reader.new(sheet_source, true, BATCH_CELLS)
+        while (values = reader.next_values(oxide_stream_converter))
+          yield values
+          yielded += 1
+        end
+        nil
+      rescue UnsupportedError
+        each_roo_row_values(sheet, yielded, &)
+      ensure
+        reader&.close
+      end
+
+      private
+
+      # The values of the rows roo's own #each_row_streaming yields, after the
+      # first `skip`.
+      def each_roo_row_values(sheet, skip)
+        method(:each_row_streaming).super_method.call do |row|
+          next skip -= 1 unless skip.zero?
+
+          yield sheet.send(:cells_for_row_element, row, pad_cells: true).map { |cell| cell&.value }
+        end
+        nil
+      end
+
+      def oxide_stream_converter
+        @oxide_stream_converter ||= Native::Converter.new(Context.new(@shared, hyperlinks(@relationships), true),
+                                                          true)
+      end
+
+      def native?
+        @path && Oxide.enabled?
+      end
+
+      # Every cell, in roo's order.
+      def read_cells(relationships)
+        cells = {}
+        reader = Native::Reader.new(sheet_source, false, BATCH_CELLS)
+        converter = Native::Converter.new(context(relationships), false)
+        nil while reader.fill_cells(cells, converter)
+        expand_merged_ranges(cells) if @options[:expand_merged_ranges]
+        cells
+      ensure
+        reader&.close
+      end
+
+      # A Native::Store, or false when the cells have to be built all at once.
+      # roo applies the hyperlinks to every cell on the first read, so later
+      # changes to the hash it hands out do not reach the cells.
+      def read_store(relationships)
+        Native::Store.read(sheet_source, context(relationships, hyperlinks(relationships).dup)) || false
+      rescue UnsupportedError
+        false
+      end
+
+      def context(relationships, links = hyperlinks(relationships))
+        Context.new(@shared, links, @options[:empty_cell])
+      end
+    end
+  end
+end

data/lib/roo/oxide/sheet_parts.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Prepended to Roo::Excelx::SheetDoc. roo finds a sheet's hyperlinks
+    # (#hyperlinks, behind every read of a sheet with a hyperlink
+    # relationship) and its merged ranges with XPath on the whole sheet.
+    # Native.sheet_parts resolves links without a Nokogiri document.
+    module SheetParts
+      # roo versions whose hyperlink and merge rules these methods reproduce.
+      ROO_VERSIONS = %w[4.0.0].freeze
+
+      def hyperlinks(relationships)
+        return super unless native? && ROO_VERSIONS.include?(Roo::VERSION)
+        return @hyperlinks if @hyperlinks
+        return @hyperlinks = {} if @options[:no_hyperlinks]
+
+        targets = relationships.oxide_hyperlink_targets
+        return @hyperlinks = {} unless targets
+        return super unless (parts = oxide_parts(targets))
+
+        @hyperlinks = parts.first
+      end
+
+      private
+
+      def expand_merged_ranges(cells)
+        return super unless (parts = oxide_parts)
+
+        merges = {}
+        parts.last.each { |ref| merge_range(merges, ref, cells) }
+        merges.each { |dst, src| cells[dst] = cells[src] }
+      end
+
+      def merge_range(merges, ref, cells)
+        src, dst = ref.split(":").map { |key| ::Roo::Utils.ref_to_key(key) }
+        return unless cells[src]
+
+        (src[0]..dst[0]).each do |row|
+          (src[1]..dst[1]).each do |col|
+            merges[[row, col]] = src unless row == src[0] && col == src[1]
+          end
+        end
+      end
+
+      # [hyperlinks, merge_cells] from Native.sheet_parts, or nil when roo
+      # reads them from the whole document.
+      def oxide_parts(targets = {})
+        return unless native? && ROO_VERSIONS.include?(Roo::VERSION)
+
+        @oxide_parts = Native.sheet_parts(sheet_source, targets) if @oxide_parts.nil?
+        @oxide_parts || nil
+      rescue UnsupportedError
+        @oxide_parts = false
+        nil
+      end
+    end
+
+    # roo's relationship nodes stay lazy; hyperlink reads need only targets.
+    module HyperlinkRelationships
+      def oxide_hyperlink_targets
+        return targets_from_roo if @relationships || !doc_exists?
+
+        Native.hyperlink_targets(@path)
+      rescue UnsupportedError
+        targets_from_roo
+      end
+
+      private
+
+      def targets_from_roo
+        return unless include_type?("hyperlink")
+
+        to_a.transform_values { |relationship| relationship["Target"] }
+      end
+    end
+  end
+end

data/lib/roo/oxide/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    VERSION = "0.0.2"
+  end
+end