roo-oxide 0.0.2

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

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