roo-oxide 0.0.2-aarch64-linux

data/lib/roo/oxide/deferred_sheets.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Prepended to Roo::Excelx. roo extracts every worksheet to its temporary
+    # directory when it opens a workbook. With the native reader on, a
+    # workbook leaves its worksheets in the zip instead:
+    # the native reader inflates the one it reads, and roo's own code finds
+    # the file extracted the first time it reads it (DeferredSheetDoc). roo
+    # reads the workbook's file only while it opens it, so it opens a snapshot
+    # in memory for small ZIPs or in its temporary directory for large ones.
+    # The workbook reads the same after its file
+    # is changed, moved, or deleted. The native extension also writes the
+    # files roo does extract, such as sharedStrings.xml: rubyzip's inflating
+    # leaves several times the file's size in short-lived Strings, which
+    # Ruby's GC frees only after they have grown the process.
+    module DeferredSheets
+      # roo versions whose workbook extraction these methods reproduce.
+      ROO_VERSIONS = %w[4.0.0].freeze
+      COMPRESSION_METHODS = [::Zip::Entry::STORED, ::Zip::Entry::DEFLATED].freeze
+      METADATA_FILES = %w[roo_workbook.xml roo_workbook.xml.rels roo_styles.xml].freeze
+      # Nokogiri's memory parser passes the byte length as a signed C int.
+      MAX_METADATA_SIZE = (2**31) - 1
+      MEMORY_ZIP_SIZE = 256 * 1024
+      private_constant :ROO_VERSIONS, :COMPRESSION_METHODS, :METADATA_FILES, :MAX_METADATA_SIZE, :MEMORY_ZIP_SIZE
+
+      # `path` as the native extension takes it. On Windows, Ruby opens a
+      # binary path's bytes as UTF-8, where magnus refuses a binary string.
+      # The extension raises EncodingError for a path it cannot take.
+      def self.native_path(path)
+        path = ::File.path(path)
+        return path unless Gem.win_platform? && path.encoding == Encoding::BINARY
+
+        path.dup.force_encoding(Encoding::UTF_8)
+      end
+
+      # Extended onto each Zip::Entry of the copy that the native extension
+      # can read: `oxide_entry` is its Native::ZipEntry, which writes the
+      # file when roo extracts the entry. When the native extraction fails,
+      # or cannot take the path, rubyzip extracts it as roo does, and raises
+      # or warns as roo does.
+      module NativeEntry
+        attr_accessor :oxide_entry, :oxide_metadata
+
+        def extract(entry_path, destination_directory:)
+          path = ::File.join(destination_directory, entry_path)
+          if oxide_metadata && METADATA_FILES.include?(entry_path) &&
+             size <= MAX_METADATA_SIZE && !::File.exist?(path)
+            oxide_metadata[entry_path] = Native.metadata_bytes(oxide_entry)
+            return self
+          end
+          oxide_entry.extract(DeferredSheets.native_path(path))
+          self
+        rescue IOError, EncodingError
+          super
+        end
+      end
+
+      # A worksheet left in the zip: `zip_entry` is rubyzip's Zip::Entry for
+      # it, a NativeEntry.
+      class Sheet
+        def initialize(zip_entry)
+          @zip_entry = zip_entry
+          @lock = Mutex.new
+          @extracted = false
+        end
+
+        # Its Native::ZipEntry.
+        def entry
+          @zip_entry.oxide_entry
+        end
+
+        # Extracts the worksheet where roo would have, once; another thread
+        # waits until the file is complete.
+        def extract(path)
+          @lock.synchronize do
+            next if @extracted
+
+            @zip_entry.extract(::File.basename(path), destination_directory: ::File.dirname(path))
+            @extracted = true
+          end
+        end
+      end
+
+      private
+
+      def process_zipfile(zipfilename_or_stream)
+        @oxide_copy = oxide_copy(zipfilename_or_stream)
+        @oxide_copy ? super(@oxide_copy) : super
+      end
+
+      # The snapshot roo opens: a stream, a copy in roo's temporary
+      # directory, or the file roo wrote there itself for a URL or
+      # `packed: :zip`. An empty file is left to roo: rubyzip's error names
+      # the file it opened.
+      def oxide_copy(source)
+        return unless Oxide.enabled? && ROO_VERSIONS.include?(Roo::VERSION)
+
+        if is_stream?(source)
+          source.seek(0)
+        elsif ::File.dirname(source) == @tmpdir
+          return source
+        end
+
+        write_oxide_copy(source)
+      end
+
+      def memory_copy(source)
+        size = is_stream?(source) ? (source.size if source.respond_to?(:size)) : ::File.size(source)
+        ::StringIO.new(is_stream?(source) ? source.read : ::File.binread(source)) if size&.between?(1, MEMORY_ZIP_SIZE)
+      end
+
+      def write_oxide_copy(source)
+        copy = memory_copy(source)
+        return copy if copy
+
+        path = "#{@tmpdir}/roo_oxide.xlsx"
+        # StringIO#read shares its full String; IO.copy_stream's partial reads copy its buffer.
+        if source.is_a?(::StringIO)
+          ::File.binwrite(path, source.read)
+        else
+          IO.copy_stream(source, path)
+        end
+        path if ::File.size?(path)
+      end
+
+      def process_zipfile_entries(entries)
+        if @oxide_copy
+          @shared.extend(MetadataShared)
+          @shared.oxide_metadata = {}
+          copy = @oxide_copy
+          zip = copy.is_a?(::StringIO) ? Native::ZipBuffer.new(copy.string) : DeferredSheets.native_path(copy)
+          native_entries(entries, zip)
+        end
+        super
+      end
+
+      # Makes each entry the native extension can read a NativeEntry. roo
+      # raises or warns while extracting an entry that is not a file,
+      # encrypted, or compressed by another method; rubyzip still extracts it.
+      def native_entries(entries, zip)
+        metadata = metadata_entries(entries)
+        entries.each do |entry|
+          next unless entry.file? && !entry.encrypted? && COMPRESSION_METHODS.include?(entry.compression_method)
+
+          entry.extend(NativeEntry).oxide_entry =
+            Native::ZipEntry.new(zip, entry.local_header_offset, entry.compressed_size, entry.size,
+                                 entry.compression_method)
+          entry.oxide_metadata = @shared.oxide_metadata if metadata.include?(entry)
+        end
+      rescue EncodingError
+        nil
+      end
+
+      def metadata_entries(entries)
+        metadata = [entries.find { |entry| entry.name[/workbook.xml$/] },
+                    entries.find { |entry| entry.name[/workbook.xml.rels$/] }]
+        styles = entries.select { |entry| entry.name.downcase[/styles.xml$/] && !entry.name.downcase[/richdata/] }
+        metadata + (styles.one? ? styles : [])
+      end
+
+      def extract_worksheet_ids(entries, path)
+        return super unless @oxide_copy
+
+        entry = entries.find { |item| item.name[/workbook.xml$/] }
+        return super unless entry.is_a?(NativeEntry)
+
+        entry.extract(::File.basename(path), destination_directory: ::File.dirname(path))
+        workbook.sheets.map { |sheet| sheet["id"] }
+      end
+
+      def extract_worksheet_rels(entries, path)
+        return super unless @oxide_copy
+
+        entry = entries.find { |item| item.name[/workbook.xml.rels$/] }
+        return super unless entry
+
+        entry.extract(::File.basename(path), destination_directory: ::File.dirname(path))
+        bytes = @shared.oxide_metadata.delete(::File.basename(path))
+        document = (bytes ? ::Nokogiri::XML(bytes, path) : Roo::Utils.load_xml(path)).remove_namespaces!
+        document.xpath("//Relationship").each_with_object({}) do |relationship, sheets|
+          sheets[relationship["Id"]] = relationship["Target"] if worksheet_types.include?(relationship["Type"])
+        end
+      end
+
+      # Roo::Excelx#extract_sheets_in_order, without the extraction. roo
+      # raises or warns reading a worksheet that is missing or that the
+      # native extension cannot read; it still does.
+      def extract_sheets_in_order(entries, sheet_ids, sheets, tmpdir)
+        found = (sheet_ids & sheets.keys).map { |id| sheet_entry(entries, sheets[id]) }
+        return super unless found.all?(NativeEntry)
+
+        deferred = found.each_with_index.to_h { |entry, i| ["#{tmpdir}/roo_sheet#{i + 1}", Sheet.new(entry)] }
+        sheet_files.concat(deferred.keys)
+        @sheet_files.concat(deferred.keys)
+        @shared.instance_variable_set(:@oxide_deferred_sheets, deferred)
+      end
+
+      def sheet_entry(entries, name)
+        name && entries.find { |e| "/#{e.name}".end_with?(name) }
+      end
+    end
+
+    # Roo constructs these extractors after extraction. Pass retained bytes
+    # alongside their original paths, including when native reading is off.
+    module MetadataShared
+      attr_accessor :oxide_metadata
+
+      def workbook
+        @workbook ||= Roo::Excelx::Workbook.new(::File.join(@dir, "roo_workbook.xml"),
+                                                oxide_xml: oxide_metadata["roo_workbook.xml"])
+      end
+
+      def styles
+        @styles ||= Roo::Excelx::Styles.new(::File.join(@dir, "roo_styles.xml"),
+                                            oxide_xml: oxide_metadata["roo_styles.xml"])
+      end
+    end
+
+    # Roo's document cache is weak: keep the source bytes so metadata can be
+    # parsed again after GC, without keeping a large Nokogiri tree alive.
+    module MetadataDocument
+      def initialize(*, oxide_xml: nil, **)
+        @oxide_xml = oxide_xml
+        super(*, **)
+      end
+
+      private
+
+      def doc
+        return super unless @oxide_xml
+
+        instance_cache(:@doc) do
+          raise Roo::FileNotFound, "#{@path} file not found" unless doc_exists?
+
+          ::Nokogiri::XML(@oxide_xml, @path).remove_namespaces!
+        end
+      end
+
+      def doc_exists?
+        @oxide_xml ? ::File.directory?(::File.dirname(@path)) : super
+      end
+    end
+
+    # Prepended to Roo::Excelx::SheetDoc, below Roo::Oxide::SheetDoc. roo
+    # reads a worksheet's file in #doc, #dimensions, and #each_row_streaming;
+    # each one extracts a deferred worksheet first.
+    module DeferredSheetDoc
+      def dimensions
+        extract_deferred_sheet
+        super
+      end
+
+      def each_row_streaming(&)
+        extract_deferred_sheet
+        super
+      end
+
+      private
+
+      def doc
+        extract_deferred_sheet
+        super
+      end
+
+      # What the native reader reads: the worksheet's Native::ZipEntry, or
+      # its file when it was not left in the zip.
+      def sheet_source
+        deferred_sheet&.entry || @path
+      end
+
+      def extract_deferred_sheet
+        deferred_sheet&.extract(@path)
+      end
+
+      # nil once the workbook is closed or collected: its temporary directory
+      # is gone, and roo raises reading the worksheet's file.
+      def deferred_sheet
+        sheet = @shared.instance_variable_get(:@oxide_deferred_sheets)&.[](@path)
+        sheet if sheet && ::File.directory?(::File.dirname(@path))
+      end
+    end
+  end
+end

data/lib/roo/oxide/excelx.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Roo
+  module Oxide
+    # Roo exposes a mutable sheet list, so names must be checked on each lookup.
+    module SheetSelection
+      private
+
+      def validate_sheet!(sheet)
+        case sheet
+        when String then super unless sheets.include?(sheet)
+        else
+          super
+        end
+      end
+    end
+
+    # Prepended to Roo::Excelx. With options, Roo::Base#each reads every value
+    # through #cell, which resolves the sheet and looks up an Array key in its
+    # cells hash, one cell at a time. These keep roo's header handling (its own
+    # private methods) and read the cells with less work per cell.
+    #
+    # Value and type lookups read the store; other single-cell lookups read
+    # Sheet#cell_at instead of Sheet#cells, and
+    # rows read Sheet#row, so they build only the cells their values need.
+    # #each without options reads the native store sequentially, or uses a
+    # RowIndex once every cell is built.
+    module Excelx
+      def each(options = {}, &)
+        return super unless block_given?
+
+        if options.empty?
+          build_cells
+          return native_rows? ? each_without_options(&) : super
+        end
+        return super unless Oxide.enabled?
+
+        each_with_headers(header_columns(options), &)
+      end
+
+      def parse(options = {})
+        return super if block_given? || options.empty? || !Oxide.enabled?
+
+        rows = rows_for(header_columns(options))
+        options[:headers] == true ? rows : rows.drop(1)
+      end
+
+      def cell(row, col, sheet = nil)
+        row, col = normalize(row, col) if row.is_a?(String) || col.is_a?(String)
+        sheet = sheet_for(sheet)
+        lazy = sheet.lazy_cells
+        return lazy.value_at(row, col) if lazy
+
+        cell = sheet.cell_at(row, col)
+        cell.value if cell.respond_to?(:value)
+      end
+
+      def formula(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)
+        cell.formula if cell.respond_to?(:formula)
+      end
+
+      def font(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)
+        definition_index = cell.style if cell.respond_to?(:style)
+        styles.definitions[definition_index] if definition_index
+      end
+
+      def celltype(row, col, sheet = nil)
+        row, col = normalize(row, col) if row.is_a?(String) || col.is_a?(String)
+        sheet = sheet_for(sheet)
+        lazy = sheet.lazy_cells
+        return lazy.type_at(row, col) if lazy
+
+        cell = sheet.cell_at(row, col)
+        cell.type if cell.respond_to?(:type)
+      end
+
+      def excelx_type(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)
+        cell.cell_type if cell.respond_to?(:cell_type)
+      end
+
+      def excelx_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)
+        cell.cell_value if cell.respond_to?(:cell_value)
+      end
+
+      def empty?(row, col, sheet = nil)
+        sheet = sheet_for(sheet)
+        key = normalize(row, col)
+        cell = (sheet.lazy_cells || sheet.cells)[key]
+        !cell || cell.empty? ||
+          (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
+      end
+
+      def set(...)
+        @oxide_set_calls = (@oxide_set_calls || 0) + 1
+        super
+      end
+
+      private
+
+      def clean_sheet(name)
+        store = sheet_for(name).lazy_cells if Oxide.enabled?
+        return super unless store
+
+        store.clean(self)
+        @cleaned[name] = true
+      end
+
+      def each_with_headers(headers)
+        first, last = headers.map(&:last).minmax
+        slots = headers.map { |key, column| [key, column - first] }
+        @header_line.upto(last_row) do |line|
+          lazy = sheet_for(nil).lazy_cells unless headers.empty?
+          yield(lazy ? lazy.hash_row(line, first, last, slots) : cells_header_row(line, headers))
+        end
+      end
+
+      def cells_header_row(line, headers)
+        cells = nil
+        headers.each_with_object({}) do |(key, column), row|
+          cells ||= sheet_for(nil).cells
+          row[key] = safe_send(cells[normalize(line, column)], :value)
+        end
+      end
+
+      # Roo::Base#each, up to its loop over the rows.
+      def header_columns(options)
+        clean_sheet_if_need(options)
+        build_cells
+        search_or_set_header(options)
+        @headers || (first_column..last_column).to_h { |column| [cell(@header_line, column), column] }
+      end
+
+      # Builds every cell before roo's next step unless the lazy cells answer it. When that raises,
+      # roo's own read raises the same error where roo raises it.
+      def build_cells
+        sheet = sheet_for(nil)
+        sheet.cells unless sheet.lazy_cells
+      rescue StandardError
+        nil
+      end
+
+      def rows_for(headers)
+        fields = headers.map { |key, column| [key, normalize(0, column).last] }
+        sheet_for(nil).parse_rows(@header_line.upto(last_row), fields)
+      end
+    end
+  end
+end

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