calcsheet 0.1.0

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

@@ -0,0 +1,594 @@
+# frozen_string_literal: true
+
+require "ox"
+require_relative "../../cast"
+require_relative "../../configuration"
+require_relative "../../errors"
+require_relative "../../grid"
+require_relative "../../odf"
+require_relative "../../untrusted"
+require_relative "../references"
+require_relative "../sax_sheet"
+require_relative "count"
+
+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.
+      #
+      # 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+.
+      # LibreOffice ends a sheet with huge runs of empty repeated rows and cells: a run is counted, never expanded,
+      # unless it holds content. Since the file is untrusted, a repeat count that is not a positive number and content
+      # beyond column XFD or row 1048576 raise MalformedFileError. A repeated cell with content puts the same value
+      # object in each of its columns, and the rows of a repeated row share their value objects (each row has its own
+      # +values+ Array): copying them would multiply the memory of a long run. Changing a value in place changes it
+      # in every row and column of the run.
+      #
+      # Values come from +office:value+ (float, percentage, currency), +office:date-value+, +office:time-value+ and
+      # +office:boolean-value+, so numbers are exact; strings from +office:string-value+ or the text. The text joins
+      # the +text:p+ paragraphs of the cell with "\n", expands +text:s+, +text:tab+ and +text:line-break+, keeps
+      # the text of spans and links, and collapses other white space as ODF does: a run of spaces, tabs and line
+      # feeds is one space, dropped at the start of a paragraph and after another space. Elements of other
+      # namespaces inside a paragraph (annotations, drawings) are ignored, and so is everything in a cell that is not
+      # one of its paragraphs. Covered (merged) cells read as nil; LibreOffice's +calcext:value-type="error"+ marks
+      # an error cell, read as nil with a :cell_error.
+      #
+      # The cell style decides how a number or a date reads, as the number format does in XLSX: a date value
+      # under a style that shows a time is a datetime (LibreOffice writes a datetime at midnight without its time), one
+      # under a style that shows no time a date, and a number under a plain zero-padding style (+00000+) gets its
+      # zeros back as a string. The style is the cell's own, else the default cell style of its row, else that of its
+      # column; +formats+ (see Scanner#cell_formats) gives the format of each style that has one. Without a known
+      # style a date value is a datetime when it has a time.
+      #
+      # The text of a cell, its +office:string-value+ included, is at most +max_cell_bytes+ long, and a number, date,
+      # time or boolean value at most Cast::MAX_NUMBER_BYTES: longer ones raise MalformedFileError before they are
+      # joined or cast.
+      #
+      # The references of a text and of the attribute values the parser reads (+&+, +A+) are decoded by the
+      # gem (see References): one to NUL or an invalid code point, which Ox would truncate or change, an unknown entity
+      # and a stray "&" raise MalformedFileError. A CDATA section is taken as it is.
+      #
+      # Elements and attributes are matched by their qualified names, built from the prefixes of the document.
+      #
+      # @api private
+      class ContentParser < Ox::Sax
+        include SaxSheet
+
+        # skip: :skip_off hands over every whitespace-only text, also the one before the end tag of an element with
+        # children ("x<text:span>a</text:span> </text:p>"), which :skip_none drops though ODF keeps it as one space.
+        # Ox then reports the whitespace of a childless element (+<text:span> </text:span>+) twice; the collapsing of
+        # #text drops the second report, which follows a space. symbolize without strip_namespace: element and
+        # attribute names come as Symbols with their prefix (+:"table:table-row"+), the keys of +@elements+ and
+        # +@attributes+, built for the prefixes of the document (#name_codes). convert_special: false, so that the
+        # references reach #text and #attr as written (see References).
+        OPTIONS = { skip: :skip_off, convert_special: false, symbolize: true }.freeze
+        # What #text collapses: a tab, a line feed, a carriage return or two spaces.
+        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 reason of a typed cell without its value attribute.
+        MISSING = { date: :invalid_date, boolean: :invalid_boolean }.freeze
+
+        # Element codes, the values of +@elements+: a Hash lookup and an Integer +case+ per callback.
+        TABLE = 1
+        ROW = 2
+        CELL = 3
+        COVERED = 4
+        PARAGRAPH = 5
+        SPACES = 6
+        TAB = 7
+        LINE_BREAK = 8
+        COLUMN = 9
+        # Attribute codes, the values of +@attributes+.
+        VALUE_TYPE = 1
+        VALUE = 2
+        DATE_VALUE = 3
+        TIME_VALUE = 4
+        BOOLEAN_VALUE = 5
+        STRING_VALUE = 6
+        CALC_VALUE_TYPE = 7
+        COLUMNS_REPEATED = 8
+        ROWS_REPEATED = 9
+        SPACE_COUNT = 10
+        STYLE_NAME = 11
+        DEFAULT_STYLE = 12
+        # 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
+
+        # Parses +io+ and yields the rows numbered +start_row+ or later.
+        #
+        # @param io [#readpartial] the table from its start tag, or from a row start tag (see Scanner::Cut)
+        # @param sheet [String] the sheet name, for errors
+        # @param prefixes [Hash{Symbol => String}] the prefixes of the office, table, text and calcext namespaces
+        # @param cast [Cast]
+        # @param types [#[], nil] the declared type per column index (see Reading)
+        # @param first_row [Integer] the number of the first row in +io+
+        # @param start_row [Integer]
+        # @param formats [Hash{String => Array(Symbol, Integer | nil)}] +[kind, pad]+ by cell style name
+        # @param max_cell_bytes [Integer, nil] the longest text of a cell; nil for no limit
+        # @yieldparam row [RawRow]
+        # @raise [MalformedFileError] for damaged XML (the parser error is the +cause+), an invalid repeat count,
+        #   content beyond the last row or column, text that is not UTF-8 or too long, or another error of the stream
+        #   (kept as +cause+)
+        # @raise [Calcsheet::Error] an error of the stream itself (a zip limit)
+        def self.parse(io, sheet:, prefixes:, cast:, types:, first_row: 1, start_row: 1, formats: NO_FORMATS,
+                       max_cell_bytes: Configuration::DEFAULTS[:max_cell_bytes], &block)
+          new(sheet: sheet, prefixes: prefixes, cast: cast, types: types, first_row: first_row, start_row: start_row,
+              formats: formats, max_cell_bytes: max_cell_bytes, on_row: block).parse(io)
+        end
+
+        # @api private
+        #
+        # 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+,
+        #   +@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),
+        #   +@yielding+ (see SaxSheet#parse);
+        # - 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 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+,
+        #   +@paragraphs+, +@paragraph+ (inside one), +@capture+ (the text is the value), +@ignored+ (the depth of an
+        #   element of another namespace), +@spaces+ (the text:s spaces so far), +@space_count+ (the +text:c+ of the
+        #   current text:s) and +@ignore_space+ (a space is dropped here: at the start of a paragraph, after a space).
+        def initialize(sheet:, prefixes:, cast:, types:, first_row:, start_row:, formats:, max_cell_bytes:, on_row:)
+          super()
+          @max_cell_bytes = max_cell_bytes
+          @sheet = sheet
+          @cast = cast
+          @types = types
+          @formats = formats.empty? ? nil : formats
+          # [first column, last column, format] of the columns whose default cell style has a format.
+          @column_formats = []
+          @columns = 0
+          @next_row = first_row
+          @start_row = start_row
+          @on_row = on_row
+          name_codes(prefixes)
+          @yielding = false
+          @element = nil
+          @in_row = false
+          @in_cell = false
+          @row_number = nil
+        end
+
+        # @api private
+        # Inside a cell only its paragraphs count: +@depth+ is the depth below the cell element.
+        def start_element(name)
+          if @in_cell
+            @depth += 1
+            @element = nil
+            if @paragraph then start_in_paragraph(name)
+            elsif @depth == 1 && @elements[name] == PARAGRAPH then begin_paragraph
+            end
+            return
+          end
+
+          @element = code = @elements[name]
+          case code
+          when ROW then begin_row
+          when CELL, COVERED then begin_cell(code) if @in_row
+          when COLUMN then begin_column
+          end
+        end
+
+        # @api private
+        def end_element(name)
+          if @in_cell
+            return finish_cell if @depth.zero?
+
+            end_in_paragraph if @paragraph
+            @element = nil
+            @depth -= 1
+            return
+          end
+
+          case @elements[name]
+          when ROW then finish_row if @in_row
+          when COLUMN then finish_column
+          when TABLE then throw STOP
+          end
+        end
+
+        # @api private
+        # The attributes the parser reads have their references decoded where they are used: a value type when it is
+        # not a known one, the value of a cell when the cell ends (#raw_value), the others here. An attribute of
+        # another element than the one it belongs to is ignored, as are those of the table (Scanner reads its name).
+        def attr(name, value)
+          case @element
+          when CELL
+            case (code = @attributes[name])
+            when VALUE_TYPE then @kind = KINDS.fetch(value) { KINDS.fetch(plain(name, value), :text) }
+            when VALUE, DATE_VALUE, TIME_VALUE, BOOLEAN_VALUE, STRING_VALUE
+              @value = value
+              @value_code = code
+            when CALC_VALUE_TYPE then @error = value == "error" || (value.include?("&") && plain(name, value) == "error")
+            when COLUMNS_REPEATED then @columns_repeated = repeat(plain(name, value), @columns_repeated_name)
+            when STYLE_NAME then @cell_style = value.include?("&") ? plain(name, value) : value
+            end
+          when COVERED
+            @columns_repeated = repeat(plain(name, value), @columns_repeated_name) if @attributes[name] == COLUMNS_REPEATED
+          when ROW
+            case @attributes[name]
+            when ROWS_REPEATED then @rows_repeated = repeat(plain(name, value), @rows_repeated_name)
+            when DEFAULT_STYLE then @row_style = plain(name, value)
+            end
+          when COLUMN
+            case @attributes[name]
+            when COLUMNS_REPEATED then @column_repeated = repeat(plain(name, value), @columns_repeated_name)
+            when DEFAULT_STYLE then @column_style = plain(name, value)
+            end
+          when SPACES
+            @space_count = plain(name, value) if @attributes[name] == SPACE_COUNT
+          end
+        end
+
+        # @api private
+        # The text of a paragraph, its references decoded unless it is a CDATA section, collapsed as ODF collapses
+        # white space.
+        def text(value, references = true)
+          return unless @capture && @paragraph && @ignored.nil?
+
+          value = text_references(value) if references && value.include?("&")
+          raise malformed("the text is not valid UTF-8", column_index: @column) unless value.valid_encoding?
+
+          if (@ignore_space && white?(value.getbyte(0))) || COLLAPSIBLE.match?(value)
+            # Like gsub(/[ \t\r\n]+/, " "), without the memory a regexp run costs per byte of a long one.
+            value = value.tr("\t\r\n", "   ").squeeze(" ")
+            value = value.byteslice(1, value.bytesize - 1) if @ignore_space && value.getbyte(0) == SPACE_BYTE
+            return if value.empty?
+          end
+          @ignore_space = value.getbyte(-1) == SPACE_BYTE
+          append(value)
+        end
+
+        # @api private
+        # A CDATA section of a paragraph, taken as it is.
+        def cdata(value)
+          text(value, false)
+        end
+
+        private
+
+        def text_references(value)
+          References.decode(value)
+        rescue References::Invalid => error
+          raise malformed("the text holds #{error.message}", column_index: @column)
+        end
+
+        # The value of an attribute with its references decoded. The column is the cell's (or the next cell's, for a
+        # row or a table-column).
+        def plain(name, value)
+          return value unless value.include?("&")
+
+          References.decode(value)
+        rescue References::Invalid => error
+          raise malformed("the attribute #{name} holds #{error.message}", column_index: (@column if @in_row))
+        end
+
+        def name_codes(prefixes)
+          table = Odf.qualifier(prefixes[:table])
+          office = Odf.qualifier(prefixes[:office])
+          text = Odf.qualifier(prefixes[:text])
+          calcext = Odf.qualifier(prefixes[:calcext])
+          @text_qualifier = text
+          @elements = {
+            "#{table}table": TABLE, "#{table}table-row": ROW, "#{table}table-cell": CELL,
+            "#{table}covered-table-cell": COVERED, "#{table}table-column": COLUMN, "#{text}p": PARAGRAPH, "#{text}s": SPACES,
+            "#{text}tab": TAB, "#{text}line-break": LINE_BREAK
+          }
+          @attributes = {
+            "#{table}number-rows-repeated": ROWS_REPEATED, "#{table}number-columns-repeated": COLUMNS_REPEATED,
+            "#{office}value-type": VALUE_TYPE, "#{office}value": VALUE, "#{office}date-value": DATE_VALUE,
+            "#{office}time-value": TIME_VALUE, "#{office}boolean-value": BOOLEAN_VALUE,
+            "#{office}string-value": STRING_VALUE, "#{calcext}value-type": CALC_VALUE_TYPE, "#{text}c": SPACE_COUNT,
+            "#{table}style-name": STYLE_NAME, "#{table}default-cell-style-name": DEFAULT_STYLE
+          }
+          @value_names = @attributes.invert.slice(VALUE, DATE_VALUE, TIME_VALUE, BOOLEAN_VALUE, STRING_VALUE)
+          @rows_repeated_name = Odf.qualified(prefixes[:table], "number-rows-repeated")
+          @columns_repeated_name = Odf.qualified(prefixes[:table], "number-columns-repeated")
+        end
+
+        # --- columns --------------------------------------------------------------------------
+
+        def begin_column
+          @column_repeated = 1
+          @column_style = nil
+        end
+
+        # Notes the columns of the element when their default cell style has a format; columns beyond the last one
+        # cannot hold cells.
+        def finish_column
+          first = @columns
+          @columns += @column_repeated
+          return unless @formats && @column_style && first < Grid::MAX_COLUMNS
+
+          format = @formats[@column_style] or return
+          @column_formats << [ first, @columns - 1, format ]
+        end
+
+        # @return [Array(Symbol, Integer | nil), nil] the format of the default cell style of the column
+        def column_format(column)
+          range = @column_formats.bsearch { |entry| entry[1] >= column }
+          range[2] if range && range[0] <= column
+        end
+
+        # @return [Array(Symbol, Integer | nil), nil] the format of the cell at +column+: of its own style, else of the
+        #   default style of its row, else of its column
+        def format_at(column)
+          return unless @formats
+
+          style = @cell_style || @row_style
+          style ? @formats[style] : column_format(column)
+        end
+
+        # --- rows -----------------------------------------------------------------------------
+
+        def begin_row
+          @in_row = true
+          @row_number = @next_row
+          @row_style = nil
+          @rows_repeated = 1
+          @values = []
+          @errors = nil
+          @last = -1
+          @column = 0
+        end
+
+        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
+          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) }
+        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)
+        end
+
+        # --- cells ----------------------------------------------------------------------------
+
+        def begin_cell(code)
+          @in_cell = true
+          @covered = code == COVERED
+          @depth = 0
+          @columns_repeated = 1
+          @kind = :text
+          @value = @value_code = nil
+          @cell_style = nil
+          @error = false
+          @text = nil
+          @paragraphs = 0
+          @paragraph = false
+          @capture = false
+          @ignored = nil
+          @spaces = 0
+        end
+
+        # An element inside a paragraph. +@ignored+ is the depth of an element of another namespace, whose content
+        # is skipped.
+        def start_in_paragraph(name)
+          return if @ignored
+
+          code = @elements[name]
+          if code == SPACES || code == TAB || code == LINE_BREAK
+            @element = code
+            @space_count = nil
+          elsif code.nil? && !text_element?(name)
+            @ignored = @depth
+          end
+        end
+
+        def end_in_paragraph
+          if @ignored
+            @ignored = nil if @ignored == @depth
+          elsif @depth == 1
+            @paragraph = false
+          elsif @capture
+            control(@element)
+          end
+        end
+
+        def text_element?(name)
+          @text_qualifier.empty? || name.start_with?(@text_qualifier)
+        end
+
+        def begin_paragraph
+          @paragraph = true
+          @capture = wants_text? if @paragraphs.zero?
+          @paragraphs += 1
+          return unless @capture
+
+          append(+"\n") if @paragraphs > 1
+          @ignore_space = true
+        end
+
+        # Whether the value of the cell is its text: no value attribute of its kind.
+        def wants_text?
+          !@covered && (@error || @value_code.nil? || @value_code != VALUE_OF[@kind])
+        end
+
+        # The end of a text:s, text:tab or text:line-break element of a paragraph.
+        def control(code)
+          case code
+          when SPACES
+            count = Count.parse(@space_count) || 1
+            @spaces += count
+            raise malformed("the text has more than #{Odf::MAX_SPACES} spaces", column_index: @column) if @spaces > Odf::MAX_SPACES
+
+            append(" " * count)
+          when TAB then append(+"\t")
+          when LINE_BREAK then append(+"\n")
+          else return
+          end
+          @ignore_space = false
+        end
+
+        # The white space of XML: space, tab (9), line feed (10) and carriage return (13).
+        def white?(byte)
+          byte == SPACE_BYTE || byte == 9 || byte == 10 || byte == 13
+        end
+
+        # Measured before it is joined: a text longer than max_cell_bytes is never built.
+        def append(text)
+          if @text
+            raise text_too_long if @max_cell_bytes && @text.bytesize + text.bytesize > @max_cell_bytes
+
+            @text << text
+          else
+            raise text_too_long if @max_cell_bytes && text.bytesize > @max_cell_bytes
+
+            @text = text
+          end
+        end
+
+        def text_too_long
+          malformed("the text is longer than max_cell_bytes (#{@max_cell_bytes} bytes)", column_index: @column)
+        end
+
+        def finish_cell
+          @in_cell = false
+          column = @column
+          raw = raw_value unless @covered
+          repeat = @columns_repeated
+          @column = column + repeat
+          return if raw.nil?
+
+          raise malformed("a cell is beyond the last column #{Grid::LAST_COLUMN}") if @column > Grid::MAX_COLUMNS
+
+          if repeat == 1
+            begin
+              @values[column] = cast(raw, @types && @types[column], format_of(column))
+            rescue Cast::Failure => failure
+              (@errors ||= []) << [ column, raw, failure.reason ]
+            end
+          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
+          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.
+        # @return [String, nil] nil for an empty cell
+        def raw_value
+          kind = @kind
+          if @error
+            @kind = :error
+            utf8(@text || "")
+          elsif @value_code && @value_code == VALUE_OF[kind]
+            value = @value.include?("&") ? plain(@value_names[@value_code], @value) : @value
+            return utf8(number_value(value)) unless kind == :string
+
+            @kind = :text
+            raise text_too_long if @max_cell_bytes && value.bytesize > @max_cell_bytes
+
+            utf8(value) unless value.empty?
+          elsif kind == :text || kind == :string
+            @kind = :text
+            utf8(@text) if @text && !@text.empty?
+          else
+            @missing = MISSING.fetch(kind, :invalid_decimal)
+            @kind = :missing
+            utf8(@text || "")
+          end
+        end
+
+        def number_value(value)
+          return value if value.bytesize <= Cast::MAX_NUMBER_BYTES
+
+          raise malformed("the value is longer than #{Cast::MAX_NUMBER_BYTES} bytes", column_index: @column)
+        end
+
+        # The format only matters to numbers and dates.
+        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)
+          end
+        end
+
+        # Ox tags the values as UTF-8, as the stream declares; it does not check the bytes.
+        def utf8(text)
+          return text if text.valid_encoding?
+
+          raise malformed("the text is not valid UTF-8", column_index: @column)
+        end
+
+        def repeat(value, name)
+          count = Count.parse(value)
+          return count if count&.positive?
+
+          raise malformed("#{name} must be a positive number, got #{Untrusted.show(value)}")
+        end
+
+        # The row being read when it is known, else the last row read.
+        def current_row
+          return @row_number if @in_row
+
+          @next_row > 1 && @row_number ? @next_row - 1 : nil
+        end
+
+        # The column of the cell being read.
+        def current_column
+          @column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Calcsheet
+  module Readers
+    module Ods
+      # The counts written in ODS attributes (repeats, spaces, digits of a number style), parsed alike by Scanner
+      # and ContentParser, so that a file reads the same from its first row and from +start_at:+.
+      #
+      # @api private
+      module Count
+        # More digits are not a count Calcsheet can use: a repeat or a number of spaces is invalid beyond them. 18
+        # digits stay below 2**62, so a count is always an immediate Integer (no Bignum) and the arithmetic on row and
+        # column numbers stays cheap; every real count (rows, columns, spaces) has far fewer digits.
+        MAX_DIGITS = 18
+        # A byte that is not an ASCII digit.
+        NOT_DIGIT = /[^0-9]/
+
+        # @param value [String, nil] an attribute value
+        # @return [Integer, nil] the number written in +value+: ASCII digits only, at most MAX_DIGITS of them; nil
+        #   otherwise. A search for another character, not an anchored /\A\d+\z/, whose backtracking costs memory in
+        #   proportion to the length of the value.
+        def self.parse(value)
+          return unless value && !value.empty? && value.bytesize <= MAX_DIGITS && value.valid_encoding?
+
+          value.to_i unless NOT_DIGIT.match?(value)
+        end
+      end
+    end
+  end
+end