calcsheet 0.1.0 → 0.2.0

data/lib/calcsheet/readers/ods/content_parser.rb

@@ -6,6 +6,7 @@ require_relative "../../configuration"
 require_relative "../../errors"
 require_relative "../../grid"
 require_relative "../../odf"
+require_relative "../../row_builder"
 require_relative "../../untrusted"
 require_relative "../references"
 require_relative "../sax_sheet"
@@ -15,8 +16,9 @@ module Calcsheet
   module Readers
     module Ods
       # Streams one table of an ODS +content.xml+ with Ox's SAX parser and hands each non-blank row to a block as a
-      # RawRow, cast with a Cast. The stream starts at the table start tag or at a row start tag inside
-      # it (see Scanner#io_at_sheet); parsing stops at the end of the table.
+      # RawRow, built by a RowBuilder: the parser places and checks each cell, the builder casts it. The stream starts
+      # at the table start tag or at a row start tag inside it (see Scanner#io_at_sheet); parsing stops at the end of
+      # the table.
       #
       # Rows are numbered by counting +table-row+ elements with their +number-rows-repeated+, cells placed by
       # counting +table-cell+ and +covered-table-cell+ elements with their +number-columns-repeated+.
@@ -69,11 +71,12 @@ module Calcsheet
         COLLAPSIBLE = /[\t\n\r]| {2}/
         # The byte of a space.
         SPACE_BYTE = 32
-        # The kind of value of each office:value-type; another type is read as text.
-        KINDS = { "float" => :number, "percentage" => :number, "currency" => :number, "date" => :date, "time" => :time,
-                  "boolean" => :boolean, "string" => :string }.freeze
+        # The kind of value of each office:value-type, a RowBuilder kind but for :string (a string whose value may be
+        # its +office:string-value+); another type is read as text.
+        KINDS = { "float" => :number, "percentage" => :number, "currency" => :number, "date" => :iso_date,
+                  "time" => :duration, "boolean" => :boolean, "string" => :string }.freeze
         # The reason of a typed cell without its value attribute.
-        MISSING = { date: :invalid_date, boolean: :invalid_boolean }.freeze
+        MISSING = { iso_date: :invalid_date, boolean: :invalid_boolean }.freeze
 
         # Element codes, the values of +@elements+: a Hash lookup and an Integer +case+ per callback.
         TABLE = 1
@@ -101,7 +104,8 @@ module Calcsheet
         # The +formats:+ of a document without cell formats.
         NO_FORMATS = {}.freeze
         # The attribute that holds the value of each kind.
-        VALUE_OF = { number: VALUE, date: DATE_VALUE, time: TIME_VALUE, boolean: BOOLEAN_VALUE, string: STRING_VALUE }.freeze
+        VALUE_OF = { number: VALUE, iso_date: DATE_VALUE, duration: TIME_VALUE, boolean: BOOLEAN_VALUE,
+                     string: STRING_VALUE }.freeze
 
         # Parses +io+ and yields the rows numbered +start_row+ or later.
         #
@@ -129,8 +133,8 @@ module Calcsheet
         #
         # The state of the parse, in instance variables so that a callback allocates nothing:
         #
-        # - set once: +@sheet+, +@cast+, +@types+, +@formats+ (nil when empty), +@start_row+, +@on_row+,
-        #   +@max_cell_bytes+, and from #name_codes +@elements+, +@attributes+, +@text_qualifier+,
+        # - set once: +@sheet+, +@builder+ (the RowBuilder of the rows), +@formats+ (nil when empty), +@start_row+,
+        #   +@on_row+, +@max_cell_bytes+, and from #name_codes +@elements+, +@attributes+, +@text_qualifier+,
         #   +@rows_repeated_name+ and +@columns_repeated_name+;
         # - across rows: +@next_row+ (the number of the next row), +@columns+ (the columns of the table-column elements
         #   so far) and +@column_formats+ (+[first, last, format]+ of those whose default cell style has a format),
@@ -138,8 +142,8 @@ module Calcsheet
         # - the element whose attributes come: +@element+ (an element code, nil inside a cell but for text:s, text:tab
         #   and text:line-break);
         # - per table-column: +@column_repeated+, +@column_style+;
-        # - per row: +@in_row+, +@row_number+, +@rows_repeated+, +@row_style+, +@values+ (sparse, see
-        #   SaxSheet#trim_row!), +@errors+, +@last+ and +@column+ (the column of the next cell);
+        # - per row: +@in_row+, +@row_number+, +@rows_repeated+, +@row_style+ and +@column+ (the column of the next
+        #   cell); its cells are in +@builder+;
         # - per cell: +@in_cell+, +@covered+, +@depth+ (below the cell element), +@columns_repeated+, +@kind+ (from the
         #   value type), +@value+ and +@value_code+ (the value attribute and which one), +@cell_style+, +@error+
         #   (+calcext:value-type="error"+), +@missing+ (the reason of a typed cell without its value), +@text+,
@@ -150,8 +154,7 @@ module Calcsheet
           super()
           @max_cell_bytes = max_cell_bytes
           @sheet = sheet
-          @cast = cast
-          @types = types
+          @builder = RowBuilder.new(cast, types, number_errors: :raw)
           @formats = formats.empty? ? nil : formats
           # [first column, last column, format] of the columns whose default cell style has a format.
           @column_formats = []
@@ -340,31 +343,33 @@ module Calcsheet
         # --- rows -----------------------------------------------------------------------------
 
         def begin_row
+          # A row nested in another one starts empty: the cells of the outer row before it are dropped.
+          @builder.finish(0) if @in_row
           @in_row = true
           @row_number = @next_row
           @row_style = nil
           @rows_repeated = 1
-          @values = []
-          @errors = nil
-          @last = -1
           @column = 0
         end
 
+        # Builds the row even before +start_row+, so that the builder starts the next one empty. The builder's row is
+        # the last of a repeated run; every row before it gets copies of its arrays.
         def finish_row
           @in_row = false
           number = @row_number
           last_number = number + @rows_repeated - 1
           @next_row = last_number + 1
-          return if @last.negative? || last_number < @start_row
+          row = @builder.finish(last_number)
+          return if row.nil? || last_number < @start_row
           raise malformed("the row is beyond the last row #{Grid::MAX_ROWS}", row: number) if last_number > Grid::MAX_ROWS
 
-          trim_row!
-          [ number, @start_row ].max.upto(last_number) { |row| emit(row, last: row == last_number) }
+          [ number, @start_row ].max.upto(last_number - 1) { |each| yield_row(copy(row, each)) }
+          yield_row(row)
         end
 
-        # Yields the row numbered +number+; every row of a repeated run but the last gets copies of the arrays.
-        def emit(number, last:)
-          yield_row(number, last ? @values : @values.dup, last || @errors.nil? ? @errors : @errors.dup)
+        # @return [RawRow] +row+ numbered +number+, with copies of its arrays
+        def copy(row, number)
+          RawRow.new(number: number, values: row.values.dup, errors: row.errors&.dup)
         end
 
         # --- cells ----------------------------------------------------------------------------
@@ -467,6 +472,9 @@ module Calcsheet
           malformed("the text is longer than max_cell_bytes (#{@max_cell_bytes} bytes)", column_index: @column)
         end
 
+        # Hands the cell to the builder as the kind of its value type, after the checks that are the parser's: its
+        # column, the length and the UTF-8 of its value. A repeated cell goes into each of its columns, cast once per
+        # declared type and format; only a number and a date ask for the formats of their columns.
         def finish_cell
           @in_cell = false
           column = @column
@@ -477,45 +485,19 @@ module Calcsheet
 
           raise malformed("a cell is beyond the last column #{Grid::LAST_COLUMN}") if @column > Grid::MAX_COLUMNS
 
+          kind = @kind
           if repeat == 1
-            begin
-              @values[column] = cast(raw, @types && @types[column], format_of(column))
-            rescue Cast::Failure => failure
-              (@errors ||= []) << [ column, raw, failure.reason ]
-            end
+            @builder.add(column, kind, raw, format_of(column), missing: @missing)
+          elsif kind == :number || kind == :iso_date
+            @builder.add_run(column, @column - 1, kind, raw, missing: @missing) { |index| format_of(index) }
           else
-            place(raw, column)
-          end
-          @last = @column - 1 if (@kind != :text || !blank?(raw)) && @column - 1 > @last
-        end
-
-        # Casts the value of a repeated cell into each of its columns, once per declared type and format.
-        def place(raw, column)
-          type = format = value = failure = nil
-          column.upto(@column - 1) do |index|
-            wanted = @types && @types[index]
-            styled = format_of(index)
-            # Identity, not equality: the formats are the frozen Arrays of the +formats+ Hash, so the same style gives
-            # the same object, and a check by identity costs nothing per column. An equal format of another style only
-            # casts once more.
-            if index == column || wanted != type || !styled.equal?(format)
-              type = wanted
-              format = styled
-              begin
-                failure = nil
-                value = cast(raw, wanted, styled)
-              rescue Cast::Failure => error
-                failure = error
-              end
-            end
-            if failure then (@errors ||= []) << [ index, raw, failure.reason ]
-            else @values[index] = value
-            end
+            @builder.add_run(column, @column - 1, kind, raw, missing: @missing)
           end
         end
 
-        # The raw value of the cell; leaves its kind in +@kind+: :text (strings), :number, :date, :time, :boolean,
-        # :error, or :missing for a typed cell without its value attribute.
+        # The raw value of the cell; leaves its RowBuilder kind in +@kind+: :text (strings), :number, :iso_date,
+        # :duration, :boolean, :error, or :missing for a typed cell without its value attribute, its reason in
+        # +@missing+.
         # @return [String, nil] nil for an empty cell
         def raw_value
           kind = @kind
@@ -546,20 +528,18 @@ module Calcsheet
           raise malformed("the value is longer than #{Cast::MAX_NUMBER_BYTES} bytes", column_index: @column)
         end
 
-        # The format only matters to numbers and dates.
+        # The format of the cell at +column+ as the builder takes it; only numbers and dates have one. The value of a
+        # number is exact, so its style only pads it: a number under a zero-padding style takes the style's
+        # +[:general, pad]+, one under a date style none (a date format would read the number as a date serial). A
+        # date takes its style's format, of which the builder reads only the kind. A format is the frozen Array of
+        # the style or nil, which RowBuilder#add_run compares by identity.
         def format_of(column)
-          format_at(column) if @kind == :number || @kind == :date
-        end
-
-        def cast(raw, type, format)
-          case @kind
-          when :text then @cast.text(raw, type)
-          when :number then @cast.number(raw, :general, type, pad: format && format[1])
-          when :date then @cast.iso_date(raw, type, format && format[0])
-          when :time then @cast.duration(raw, type)
-          when :boolean then @cast.boolean(boolean(raw), type)
-          when :error then raise Cast::Failure.new(:cell_error, raw)
-          else raise Cast::Failure.new(@missing, raw)
+          kind = @kind
+          if kind == :number
+            format = format_at(column)
+            format if format && format[0] == :general
+          elsif kind == :iso_date
+            format_at(column)
           end
         end
 

data/lib/calcsheet/readers/ods/scanner.rb

@@ -93,7 +93,9 @@ module Calcsheet
           @hidden_styles = nil
           @head_formats = nil
           @cell_formats = nil
+          # Every table, once a scan reached the end of the entry; the tables met so far by #each_sheet.
           @sheets = nil
+          @known_sheets = nil
         end
 
         # @return [Hash{Symbol => String}] the prefix of each namespace of NAMESPACES ("" for the default namespace);
@@ -125,17 +127,42 @@ module Calcsheet
         # @raise [MalformedFileError] for a damaged document, a sheet name that is not UTF-8 or a bound exceeded
         # @raise [TooManySheetsError] for more tables than +max_sheets+
         def sheets
-          @sheets ||= walk do |cursor|
-            list = []
+          each_sheet { nil } unless @sheets
+          @sheets
+        end
+
+        # Yields the tables in document order, scanning only as far as the caller reads: one that stops at the first
+        # table (the default sheet of a read) inflates the part of the entry before it, not the whole entry. The
+        # tables met are kept; asked for more, the scan starts again from the start and goes on past them. A damaged
+        # document, a bad name or more tables than +max_sheets+ raise only when the scan reaches them.
+        #
+        # @yieldparam sheet [SheetInfo]
+        # @return [Enumerator, nil] an Enumerator without a block
+        # @raise [MalformedFileError] for a damaged document, a sheet name that is not UTF-8 or a bound exceeded
+        # @raise [TooManySheetsError] for more tables than +max_sheets+
+        def each_sheet
+          return enum_for(:each_sheet) unless block_given?
+          return @sheets.each { yield _1 } if @sheets
+
+          known = (@known_sheets ||= [])
+          known.each { yield _1 }
+          walk do |cursor|
+            count = 0
             each_table(cursor) do |tag|
-              if @max_sheets && list.size == @max_sheets
-                raise TooManySheetsError.new(limit: :max_sheets, max: @max_sheets, actual: list.size + 1)
+              if @max_sheets && count == @max_sheets
+                raise TooManySheetsError.new(limit: :max_sheets, max: @max_sheets, actual: count + 1)
               end
 
-              list << sheet_info(tag, list.size)
+              count += 1
+              next if count <= known.size
+
+              info = sheet_info(tag, count - 1)
+              known << info
+              yield info
             end
-            list.freeze
+            @sheets = known.dup.freeze
           end
+          nil
         end
 
         # Inflates the entry from its start and stops at the table of the sheet, or at the row start tag holding

data/lib/calcsheet/readers/ods_reader.rb

@@ -48,6 +48,15 @@ module Calcsheet
         @scanner.sheets
       end
 
+      # The sheets, scanned only as far as the caller reads (see Reading for the backend contract).
+      # @yieldparam sheet [SheetInfo]
+      # @return [Enumerator, nil] an Enumerator without a block
+      # @raise [MalformedFileError] for a damaged content.xml, when the scan reaches it
+      # @raise [TooManySheetsError] for more tables than +max_sheets+, when the scan reaches them
+      def each_sheet(&block)
+        @scanner.each_sheet(&block)
+      end
+
       # Holds nothing between reads: each read closes its own stream.
       def close
         nil
@@ -55,8 +64,14 @@ module Calcsheet
 
       private
 
+      # @return [SheetInfo] the sheet at +index+, scanning the tables up to it
+      # @raise [IndexError] when there is no such sheet
+      def sheet_at(index)
+        each_sheet.find { _1.index == index } or raise IndexError, "no sheet #{index}"
+      end
+
       def each_row(index, cast, types, start_row, &block)
-        sheet = sheets.fetch(index)
+        sheet = sheet_at(index)
         io = @scanner.io_at_sheet(index, row: start_row) or return
         begin
           Ods::ContentParser.parse(io, sheet: sheet.name, prefixes: @scanner.prefixes, cast: cast, types: types,

data/lib/calcsheet/readers/sax_sheet.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
 require "ox"
-require_relative "../cast"
 require_relative "../errors"
 require_relative "../limited_inflater"
 require_relative "../raw_row"
-require_relative "../reading"
 require_relative "ox_errors"
 
 module Calcsheet
   module Readers
     # What the SAX parsers of one sheet (Xlsx::SheetParser, Ods::ContentParser) share: parsing until they throw STOP,
-    # the translation of parser errors, errors located at the sheet, row and column, and the end of a row.
+    # the translation of parser errors, errors located at the sheet, row and column, and the handing over of a row.
+    # Their cells become rows in a RowBuilder.
     #
     # The including class defines OPTIONS (for Ox.sax_parse), +current_row+ and +current_column+ (where an error is
-    # located), and keeps +@sheet+ (the sheet name), +@on_row+ (the block rows are yielded to), +@values+, +@errors+
-    # (+[column, raw, reason]+ per failed cell, or nil), +@last+ (the last non-blank column, -1 for none) and
-    # +@in_cell+. +@yielding+ is true while the caller's block runs.
+    # located), and keeps +@sheet+ (the sheet name), +@on_row+ (the block rows are yielded to) and +@in_cell+.
+    # +@yielding+ is true while the caller's block runs.
     #
     # @api private
     module SaxSheet
@@ -46,54 +44,14 @@ module Calcsheet
 
       private
 
-      # Drops what follows the last non-blank cell: the values (a failed cast leaves the last non-blank cell nil,
-      # whitespace after it is trimmed) and, like CSV, the cast failures of the whitespace after it. +@errors+ is nil
-      # when none is left, else sorted by column.
-      #
-      # +@values+ is sparse: a cell sets only its own position, so the Array is as long as the last cell that got a
-      # value, nil before it where cells were empty or missing. A cell whose cast failed, or an error cell, sets
-      # nothing: when it is the last non-blank one and no whitespace text after it got a value, the Array is shorter
-      # than +@last+ + 1, and assigning nil at +@last+ extends it to that cell. Otherwise the values after +@last+
-      # (whitespace texts) are popped.
-      def trim_row!
-        if @values.size <= @last
-          @values[@last] = nil
-        else
-          @values.pop while @values.size > @last + 1
-        end
-        return unless @errors
-
-        @errors.reject! { |error| error[0] > @last }
-        if @errors.empty? then @errors = nil
-        elsif @errors.size > 1 then @errors.sort_by!(&:first)
-        end
-      end
-
-      # Hands a row to the caller's block; its errors are the block's own: +@yielding+ tells #parse not to translate
+      # Hands a RawRow to the caller's block; its errors are the block's own: +@yielding+ tells #parse not to translate
       # them.
-      def yield_row(number, values, errors)
-        row = RawRow.new(number: number, values: values, errors: errors)
+      def yield_row(row)
         @yielding = true
         @on_row.call(row)
         @yielding = false
       end
 
-      # Whitespace only, without a regexp for the common text that starts with a printable ASCII character.
-      def blank?(text)
-        byte = text.getbyte(0)
-        !(byte > 32 && byte < 128) && !Reading::NON_BLANK.match?(text)
-      end
-
-      # The texts of a boolean value in XLSX ("1", "0") and ODS ("true", "false"); both formats accept both. A case of
-      # String literals, which Ruby dispatches by hash, costs less per cell than a Hash or Array lookup.
-      def boolean(text)
-        case text
-        when "1", "true" then true
-        when "0", "false" then false
-        else raise Cast::Failure.new(:invalid_boolean, text)
-        end
-      end
-
       # The zip stream refused a text or a tag too long for max_cell_bytes: located like the parser's own errors.
       def token_too_long(error)
         malformed("a text or a tag is longer than max_cell_bytes (#{error.max_cell_bytes} bytes) allows",

data/lib/calcsheet/readers/xlsx/sheet_parser.rb

@@ -5,6 +5,7 @@ require_relative "../../cast"
 require_relative "../../configuration"
 require_relative "../../errors"
 require_relative "../../grid"
+require_relative "../../row_builder"
 require_relative "../../untrusted"
 require_relative "../sax_sheet"
 require_relative "escapes"
@@ -13,9 +14,9 @@ require_relative "../references"
 module Calcsheet
   module Readers
     module Xlsx
-      # Streams the XML of one sheet with Ox's SAX parser and hands each non-blank row to a block as a RawRow, cast
-      # with a Cast. Parsing stops at the end of +sheetData+, so what follows it (merged ranges,
-      # hyperlinks...) is never read.
+      # Streams the XML of one sheet with Ox's SAX parser and hands each non-blank row to a block as a RawRow, built
+      # by a RowBuilder: the parser places and checks each cell, the builder casts it. Parsing stops at the end of
+      # +sheetData+, so what follows it (merged ranges, hyperlinks...) is never read.
       #
       # Rows are numbered by their +r+ attribute, counted on from the previous row when it is absent; cells are
       # placed by the column letters of their +r+, after the previous cell when it is absent. Element names
@@ -80,15 +81,14 @@ module Calcsheet
         #
         # The state of the parse, in instance variables so that a callback allocates nothing:
         #
-        # - set once: +@sheet+, +@cast+, +@types+, +@styles+ (the WorkbookMeta), +@strings+ (the lambda that loads the
-        #   shared strings) and +@table+ (the SharedStrings, loaded at the first +t="s"+ cell), +@start_row+,
-        #   +@on_row+ (the caller's block), +@max_cell_bytes+, +@style_kinds+ (the memo of #style_kind);
+        # - set once: +@sheet+, +@builder+ (the RowBuilder of the rows), +@styles+ (the WorkbookMeta), +@strings+ (the
+        #   lambda that loads the shared strings) and +@table+ (the SharedStrings, loaded at the first +t="s"+ cell),
+        #   +@start_row+, +@on_row+ (the caller's block), +@max_cell_bytes+, +@style_kinds+ (the memo of #style_kind);
         # - across rows: +@last_number+ (the number of the last row read, 0 before the first) and +@yielding+ (the
         #   caller's block runs; see SaxSheet#parse);
         # - the element whose attributes come: +@element+;
-        # - per row (#begin_row): +@in_row+, +@row_number+ (its +r+, nil without one), +@values+ (sparse, see
-        #   SaxSheet#trim_row!), +@errors+, +@last+ (the last non-blank column, -1 for none) and +@next_column+ (the
-        #   column of a cell without +r+);
+        # - per row (#begin_row): +@in_row+, +@row_number+ (its +r+, nil without one) and +@next_column+ (the column
+        #   of a cell without +r+); its cells are in +@builder+;
         # - per cell (+c+): +@in_cell+ (inside a row), +@column+ (from its +r+, nil without one), +@cell_type+ (its
         #   +t+), +@style+ (its +s+) and +@text+ (the text joined so far, nil before any);
         # - per text: +@capture+ (the text of +v+, or of a +t+ of the inline string outside phonetic runs, is the
@@ -101,8 +101,9 @@ module Calcsheet
           @text_limit = nil
           @bounded = false
           @sheet = sheet
-          @cast = cast
-          @types = types
+          # A number cell that fails an :integer type reports the number as read (Cast#integer_number), not the full
+          # print of a double that Excel writes.
+          @builder = RowBuilder.new(cast, types, number_errors: :as_read)
           @styles = styles
           @strings = strings
           @table = nil
@@ -157,7 +158,7 @@ module Calcsheet
           when :c
             finish_cell if @in_cell
             # The text ends with its cell, also for a cell nested in an inline string: no later text is joined to
-            # it, and @text (a shared string, or the raw value of a cast error) is never changed afterwards.
+            # it, and @text (the raw value of a cast error) is never changed afterwards.
             @text = nil
             @capture = false
             @inline = false
@@ -237,24 +238,26 @@ module Calcsheet
         end
 
         def begin_row
+          # A row nested in another one starts empty: the cells of the outer row before it are dropped.
+          @builder.finish(0) if @in_row
           @in_row = true
           @row_number = nil
-          @values = []
-          @errors = nil
-          @last = -1
           @next_column = 0
         end
 
+        # Builds the row even before +start_row+, so that the builder starts the next one empty.
         def finish_row
           @in_row = false
           number = @row_number || counted_row
           @last_number = number
-          return if @last.negative? || number < @start_row
-
-          trim_row!
-          yield_row(number, @values, @errors)
+          row = @builder.finish(number)
+          yield_row(row) if row && number >= @start_row
         end
 
+        # Hands the cell to the builder as the kind of its type, after the checks that are the parser's: the UTF-8 of
+        # the text and of an unknown type, the style index of a number or a date, the index of a shared string. A
+        # style decides the +[kind, pad]+ of a number and the kind of a date; the builder reads only the kind of the
+        # latter, so the date takes the style's own Array, without allocating one per cell.
         def finish_cell
           @in_cell = false
           column = @column || @next_column
@@ -263,43 +266,20 @@ module Calcsheet
           @next_column = column + 1
           return if @text.nil?
 
-          value = cell_value(column)
-          @values[column] = value unless value.nil?
-        rescue Cast::Failure => failure
-          (@errors ||= []) << [ column, error_text(failure), failure.reason ]
-        end
-
-        # The text of a failed cast: the cell's text, or for a number cell declared :integer that holds a fraction the
-        # number as read (Cast#integer_number), not the full print of a double that Excel writes.
-        def error_text(failure)
-          failure.reason == :not_integral && (@cell_type.nil? || @cell_type == "n") ? failure.value : @text
-        end
-
-        # The cell's value, cast; before the cast, moves @last to the cell when its raw content is not blank. A
-        # string cell leaves its text in @text, for the error of a failed cast.
-        def cell_value(column)
-          type = @types && @types[column]
           case @cell_type
           when nil, "n"
-            @last = column if column > @last
-            kind, pad = @style ? @style_kinds[@style] || style_kind(@style, column) : @styles.style_kind(0)
-            @cast.number(utf8(@text, column), kind, type, pad: pad)
-          when "s" then string_value(@text = shared_string(column), column, type)
-          when "inlineStr", "str" then string_value(Escapes.decode!(utf8(@text, column)), column, type)
-          when "b"
-            @last = column if column > @last
-            utf8(@text, column)
-            @cast.boolean(boolean(@text), type)
-          when "e"
-            utf8(@text, column)
-            error_value(column)
+            format = @style ? @style_kinds[@style] || style_kind(@style, column) : @styles.style_kind(0)
+            @builder.add(column, :number, utf8(@text, column), format)
+          when "s" then @builder.add(column, :text, shared_string(column))
+          when "inlineStr", "str" then @builder.add(column, :text, Escapes.decode!(utf8(@text, column)))
+          when "b" then @builder.add(column, :boolean, utf8(@text, column))
+          when "e" then @builder.add(column, :error, utf8(@text, column))
           when "d"
-            @last = column if column > @last
-            kind, = @style ? @style_kinds[@style] || style_kind(@style, column) : @styles.style_kind(0)
-            @cast.iso_date(utf8(@text, column), type, kind)
+            format = @style ? @style_kinds[@style] || style_kind(@style, column) : @styles.style_kind(0)
+            @builder.add(column, :iso_date, utf8(@text, column), format)
           else
             attribute_utf8(@cell_type)
-            string_value(utf8(@text, column), column, type)
+            @builder.add(column, :text, utf8(@text, column))
           end
         end
 
@@ -330,19 +310,6 @@ module Calcsheet
           raise malformed("an attribute value is not valid UTF-8", row: row)
         end
 
-        def string_value(text, column, type)
-          return if text.empty?
-
-          @last = column if column > @last && !blank?(text)
-          @cast.text(text, type)
-        end
-
-        def error_value(column)
-          @last = column if column > @last
-          (@errors ||= []) << [ column, @text, :cell_error ]
-          nil
-        end
-
         def shared_string(column)
           @table ||= @strings.call
           index = Integer(@text, 10, exception: false)

data/lib/calcsheet/reading.rb

@@ -7,6 +7,7 @@ require_relative "merge_check"
 require_relative "raw_row"
 require_relative "raw_types"
 require_relative "row"
+require_relative "row_builder"
 require_relative "schema"
 require_relative "sheet_selection"
 
@@ -29,14 +30,30 @@ module Calcsheet
   #   breaking out of the block stops reading.
   # - +#close+: releases what the backend opened (never the source, which the book closes).
   # - optionally +#date1904?+: the workbook counts date serials from 1904.
+  # - optionally +#each_sheet { |SheetInfo| }+ (an Enumerator without a block): the sheets of +#sheets+, in order,
+  #   found only as far as the caller reads them, for a format that must scan to list its sheets (ODS). Without
+  #   +precheck_sheets+, a read selects its sheets through it, so that the default sheet does not cost a scan of
+  #   the whole file.
+  # - optionally +#end_row(sheet_index)+ -> Array(Integer, Integer | nil), nil: after an +each_raw_batch+ of the
+  #   sheet that read to its end, the number and line of the row that would follow its last one, blank or not, when
+  #   the blank rows at the end are rows of the sheet (CSV records). Without it, or nil, they are not: a sheet ends
+  #   with its last non-blank row.
   #
-  # Rows are numbered as the user sees them; +values+ are in file order with trailing blank cells trimmed.
+  # Rows are numbered as the user sees them; +values+ are in file order, trimmed after the last non-blank cell or,
+  # after it, the last whitespace text that the declared type keeps as text (:string, or the native value).
   # Each cell is cast with +cast+ (a Cast) and the declared type +types[column_index]+, where +types+ is nil or
   # an object answering +[](column_index)+ with a type of TYPES or nil (an Array, or a RawTypes, which also gives
   # a type to the columns beyond its entries); nil means the native value. A backend rescues Cast::Failure per
   # cell, puts nil in +values+ and appends +[column_index, raw_value, reason]+ to +errors+. The Options of the read
   # (which may override those of the book, but not OPEN_KEYS) are +cast.options+.
   #
+  # calcsheet-native depends on this contract: change it only in a minor release and together with the protocol
+  # version (see NativeBackends).
+  #
+  # The Ruby backends hand their raw cells to a RowBuilder, which applies these rules in one place: the casts,
+  # the failures (+errors+ nil when none, else sorted by column), the trimming (a :text of whitespace only is blank,
+  # every other cell is not) and the failures of the whitespace after the row.
+  #
   # Reading itself is the facade's: Book builds one per read.
   class Reading
     # The read options; every other keyword is an Options override.
@@ -44,7 +61,7 @@ module Calcsheet
     # The Options the book applies when the file is opened (the source, the zip archive, the backend): a read cannot
     # override them.
     OPEN_KEYS = %i[max_file_size max_uncompressed_size max_compression_ratio compression_ratio_floor max_zip_entries
-                   max_sheets max_cell_bytes].freeze
+                   max_sheets max_cell_bytes backend precheck_sheets].freeze
     # The errors of a row without any, shared.
     NO_ERRORS = [].freeze
     # A character that is not whitespace: a text is blank unless it has one. A search, not an anchored
@@ -66,7 +83,8 @@ module Calcsheet
     attr_writer :open_check
 
     # @api private
-    # @param sheets [Array<SheetInfo>] every sheet of the book
+    # @param sheets [Enumerable<SheetInfo>] every sheet of the book, in order: an Array, or a SheetList that finds
+    #   them as far as the selection reads
     # @param options [Options] the options of the book
     # @param overrides [Hash] Options overrides of this read
     # @raise [ArgumentError] on an invalid read option or an override of an OPEN_KEYS option
@@ -221,7 +239,7 @@ module Calcsheet
       @backend.each_raw_batch(sheet.index, size: size, cast: @cast, types: @types, start_row: first) do |batch|
         batch.each do |raw|
           unless @skip_blank
-            (expected...raw.number).each { |number| yield blank_row(raw, number) }
+            (expected...raw.number).each { |number| yield blank_row(number, raw.number, raw.line) }
             expected = raw.number + 1
           end
           yield raw
@@ -229,11 +247,15 @@ module Calcsheet
         # A book closed while its rows were yielded stops the read before the backend reads on.
         @open_check&.call
       end
+      return if @skip_blank || !@backend.respond_to?(:end_row)
+
+      number, line = @backend.end_row(sheet.index)
+      (expected...number).each { |blank| yield blank_row(blank, number, line) } if number
     end
 
-    # A blank row before +following+: a blank record or row is one physical line.
-    def blank_row(following, number)
-      RawRow.new(number: number, line: following.line && following.line - (following.number - number), values: [])
+    # A blank row before the row +following+ that starts at +line+: a blank record or row is one physical line.
+    def blank_row(number, following, line)
+      RawRow.new(number: number, line: line && line - (following - number), values: [])
     end
 
     def convert(sheet, raw)