calcsheet 0.1.0 → 0.2.0

data/lib/calcsheet/writers/xlsx_writer.rb

@@ -8,7 +8,9 @@ require_relative "../column_letter"
 require_relative "../decimal_text"
 require_relative "../errors"
 require_relative "../excel_serial"
+require_relative "../formula"
 require_relative "../grid"
+require_relative "../style"
 require_relative "xml_text"
 require_relative "zip_buffered"
 
@@ -20,9 +22,10 @@ module Calcsheet
     # "+39..." and "=..." stay verbatim. The parts that list every sheet (workbook, relationships, content
     # types) and the styles, known only at the end, are written after the sheets; zip entries have no required order.
     #
-    # Styles: the default, the bold header, and one per number format a column needs: decimals with +scale+ (the
-    # full value is stored, the format shows +scale+ decimals), dates and datetimes. They are numbered in the order
-    # the columns first use them.
+    # Styles: the default, the bold header, one per number format a column needs: decimals with +scale+ (the
+    # full value is stored, the format shows +scale+ decimals), dates and datetimes, and one per Style and number
+    # format the rows use (fonts, fills and borders shared between them). They are numbered in the order they are
+    # first used. A formula is written without a cached value, and the workbook asks to be computed when it opens.
     #
     # @api private
     class XlsxWriter
@@ -65,30 +68,45 @@ module Calcsheet
         @styles = {}
         @cell_formats = []
         @number_formats = {}
+        @fonts = { [ nil, nil, nil, nil ] => 0, [ true, nil, nil, nil ] => 1 }
+        @fills = { nil => 0, gray125: 1 }
+        @borders = { nil => 0 }
+        @letters_cache = {}
+        @formulas = false
         @buffer = new_buffer
         @entry = nil
+        @deferred = nil
       end
 
-      # Opens the sheet's zip entry and writes its start, column widths and header row.
+      # Opens the sheet's zip entry and writes its start, column widths and header row; with +auto_width+, the rows
+      # go to a temporary file and the entry is written when the sheet ends, its widths known.
       # @raise [ArgumentError] for more columns than XLSX holds
       # @raise [WriteError] for a header longer than a cell holds
-      def start_sheet(name, columns, header:)
-        check_sheet(name, columns)
+      def start_sheet(name, columns, header:, widths: nil, auto_width: false)
+        check_sheet(name, columns) if columns
         @sheet_names << name
         @name = name
         @columns = columns
-        @types = columns.map(&:type)
+        @types = columns&.map(&:type)
+        @header = header
         @row_number = 0
-        prepare_cells(columns)
-        @entry = @zip.write_deflated_file("xl/worksheets/sheet#{@sheet_names.size}.xml")
-        @buffer << sheet_start(columns, header)
+        @merges = []
+        prepare_cells(columns) if columns
+        if auto_width
+          defer_rows
+        else
+          open_sheet_entry(cols(columns ? columns.map(&:width) : widths || []))
+        end
         write_header(columns) if header
       end
 
-      # Writes one row of checked values (see the contract in WriteBook) from the constant parts of #prepare_cells.
+      # Writes one row of checked values (see the contract in WriteBook): a typed row without styles or formulas from
+      # the constant parts of #prepare_cells, any other cell by cell.
       # @raise [WriteError] for a date beyond the serials or a text longer than a cell; nothing of the row is written
-      def row(values)
+      def row(values, styles = nil)
         mark = @buffer.bytesize
+        return any_row(values, styles) if styles || @types.nil? || values.any?(Formula)
+
         number = (@row_number + 1).to_s
         @buffer << '<row r="' << number << '">'
         index = 0
@@ -110,10 +128,25 @@ module Calcsheet
         raise
       end
 
-      # Ends the sheet's XML and closes its zip entry.
-      def end_sheet
-        @buffer << "</sheetData></worksheet>"
-        flush
+      # @param range [CellRange] written after the rows, as XLSX keeps them
+      def merge(range)
+        @merges << range
+      end
+
+      # Ends the sheet's XML and closes its zip entry; with +auto_width+, writes the entry with +widths+ first.
+      def end_sheet(widths = nil)
+        @buffer << "</sheetData>" << merge_cells << "</worksheet>"
+        if @deferred
+          tail = @buffer.dup
+          @buffer.clear
+          flush
+          open_sheet_entry(cols(widths || []))
+          flush
+          replay_deferred
+          @entry << tail
+        else
+          flush
+        end
         @entry.close
         @entry = nil
       end
@@ -137,7 +170,7 @@ module Calcsheet
           next if value.nil?
 
           reason =
-            case @types[index]
+            case type_of(value, index)
             # A text of at most 32,767 bytes has at most as many UTF-16 code units (a UTF-8 character takes at least as
             # many bytes as it takes units): only a longer one is counted.
             when :string then length_reason(excel_length(value)) if value.bytesize > Grid::MAX_CELL_CHARACTERS && excel_length(value) > Grid::MAX_CELL_CHARACTERS
@@ -197,8 +230,10 @@ module Calcsheet
       # +[numFmtId, fontId]+: the header is the General format (0) in the bold font (1, see #styles_xml), a number
       # format its custom format in the default font (0).
       def style(key)
+        return 0 if key.nil?
+
         @styles[key] ||= begin
-          @cell_formats << (key == HEADER_STYLE ? [ 0, 1 ] : [ number_format(key), 0 ])
+          @cell_formats << (key == HEADER_STYLE ? [ 0, 1, 0, 0, nil ] : [ number_format(key), 0, 0, 0, nil ])
           @cell_formats.size
         end
       end
@@ -207,30 +242,151 @@ module Calcsheet
         @number_formats[code] ||= FIRST_CUSTOM_FORMAT + @number_formats.size
       end
 
-      def sheet_start(columns, header)
+      # Opens the sheet's zip entry with its start, up to the rows.
+      def open_sheet_entry(cols_xml)
+        @entry = @zip.write_deflated_file("xl/worksheets/sheet#{@sheet_names.size}.xml")
+        @entry << sheet_start(cols_xml, @header)
+      end
+
+      def sheet_start(cols_xml, header)
         xml = +DECLARATION
         xml << %(<worksheet xmlns="#{MAIN_NS}" xmlns:r="#{REL_NS}"><sheetViews><sheetView)
         xml << ' tabSelected="1"' if @sheet_names.size == 1
         xml << ' workbookViewId="0"'
         xml << (header ? ">#{FROZEN_HEADER}</sheetView>" : "/>")
         xml << "</sheetViews>"
-        xml << widths(columns)
+        xml << cols_xml
         xml << "<sheetData>"
       end
 
-      def widths(columns)
-        cols = columns.each_with_index.filter_map do |column, index|
-          next if column.width.nil?
+      # @param widths [Array<Numeric, nil>] by column index
+      def cols(widths)
+        cols = widths.each_with_index.filter_map do |width, index|
+          next if width.nil?
 
-          %(<col min="#{index + 1}" max="#{index + 1}" width="#{number_text(column.width)}" customWidth="1"/>)
+          %(<col min="#{index + 1}" max="#{index + 1}" width="#{number_text(width)}" customWidth="1"/>)
         end
         cols.empty? ? "" : "<cols>#{cols.join}</cols>"
       end
 
+      def merge_cells
+        return "" if @merges.empty?
+
+        %(<mergeCells count="#{@merges.size}">#{@merges.map { %(<mergeCell ref="#{_1}"/>) }.join}</mergeCells>)
+      end
+
+      # A row of any sheet, cell by cell: the type of each value is its column's, or its class's in a free sheet,
+      # a formula's whatever the column; a styled nil is a styled empty cell.
+      def any_row(values, styles)
+        mark = @buffer.bytesize
+        number = (@row_number + 1).to_s
+        @buffer << '<row r="' << number << '">'
+        count = [ values.size, styles&.size || 0 ].max
+        index = 0
+        while index < count
+          value = values[index]
+          style = styles&.[](index)
+          if value.nil?
+            @buffer << '<c r="' << letter(index) << number << '" s="' << xf(style, nil).to_s << '"/>' if style
+          else
+            any_cell(value, index, number, style)
+          end
+          index += 1
+        end
+        @buffer << "</row>"
+        @row_number += 1
+        flush if @buffer.bytesize >= BUFFER_SIZE
+      rescue StandardError
+        rollback(mark)
+        raise
+      end
+
+      def any_cell(value, index, number, style)
+        type = type_of(value, index)
+        code = style&.format&.code || default_format(type, index)
+        @buffer << '<c r="' << letter(index) << number << '"'
+        @buffer << ' s="' << xf(style, code).to_s << '"' if style || code
+        case type
+        when :formula
+          @formulas = true
+          @buffer << "><f>" << XmlText.escape(value.text) << "</f></c>"
+        when :string
+          @buffer << ' t="inlineStr"><is><t xml:space="preserve">'
+          value_text(value, :string, index)
+          @buffer << "</t></is></c>"
+        when :boolean then @buffer << ' t="b"><v>' << (value ? "1" : "0") << "</v></c>"
+        else
+          @buffer << "><v>"
+          value_text(value, type, index)
+          @buffer << "</v></c>"
+        end
+      end
+
+      # The type a value is written as: a formula, its column's type, or in a free sheet its class's.
+      def type_of(value, index)
+        return :formula if value.is_a?(Formula)
+        return @types[index] if @types
+
+        case value
+        when String then :string
+        when Integer then :integer
+        when BigDecimal then :decimal
+        when Time then :datetime
+        when Date then :date
+        else :boolean
+        end
+      end
+
+      # The number format of a cell without a style that gives one: its column's, or a date's or time's.
+      def default_format(type, index)
+        return format_of(@columns[index]) if @columns && type != :formula
+
+        case type
+        when :date then DATE_FORMAT
+        when :datetime then DATETIME_FORMAT
+        end
+      end
+
+      def letter(index)
+        @letters_cache[index] ||= ColumnLetter.from_index(index).freeze
+      end
+
       def number_text(number)
         number.is_a?(Integer) ? number.to_s : Float(number).to_s
       end
 
+      # The cellXfs index of a Style with a number format code (either may be nil), registered at its first use; a
+      # Style that sets only the number format shares the index of that format.
+      def xf(style, code)
+        return style(code) if style.nil? || style.plain?
+
+        @styles[[ style, code ]] ||= begin
+          @cell_formats << [ code ? number_format(code) : 0, font(style), fill(style), border(style), alignment(style) ]
+          @cell_formats.size
+        end
+      end
+
+      def font(style)
+        key = [ style.bold || nil, style.italic || nil, style.size, style.color ]
+        @fonts[key] ||= @fonts.size
+      end
+
+      def fill(style)
+        @fills[style.fill] ||= @fills.size
+      end
+
+      def border(style)
+        @borders[style.border] ||= @borders.size
+      end
+
+      def alignment(style)
+        attributes = []
+        attributes << %(horizontal="#{style.align}") if style.align
+        attributes << %(vertical="#{style.valign}") if style.valign
+        attributes << 'wrapText="1"' if style.wrap
+        attributes.empty? ? nil : "<alignment #{attributes.join(" ")}/>"
+      end
+
       def write_header(columns)
         style = style_attribute(HEADER_STYLE)
         @buffer << '<row r="1">'
@@ -243,7 +399,11 @@ module Calcsheet
       end
 
       def cell(value, index)
-        case @types[index]
+        value_text(value, @types[index], index)
+      end
+
+      def value_text(value, type, index)
+        case type
         when :string
           check_length(value, index) if value.bytesize > Grid::MAX_CELL_CHARACTERS
           @buffer << XmlText.escape(value, ooxml: true)
@@ -284,7 +444,7 @@ module Calcsheet
       # @raise [WriteError] at the row being written
       def refuse(reason, index)
         row = @row_number + 1
-        raise WriteError.at(reason, sheet: @name, row: row, column_index: index, header: @columns[index].header)
+        raise WriteError.at(reason, sheet: @name, row: row, column_index: index, header: @columns&.[](index)&.header)
       end
 
       # The characters of +text+ as Excel counts them: one beyond the Basic Multilingual Plane counts twice.
@@ -296,29 +456,58 @@ module Calcsheet
 
       def styles_xml
         formats = @number_formats.map { |code, id| %(<numFmt numFmtId="#{id}" formatCode="#{XmlText.escape(code)}"/>) }
-        xfs = [ [ 0, 0 ], *@cell_formats ].map do |format, font|
-          attributes = %(numFmtId="#{format}" fontId="#{font}" fillId="0" borderId="0" xfId="0")
-          attributes += ' applyNumberFormat="1"' unless format.zero?
-          attributes += ' applyFont="1"' unless font.zero?
-          "<xf #{attributes}/>"
-        end
-        font = '<sz val="11"/><name val="Calibri"/><family val="2"/>'
+        xfs = [ [ 0, 0, 0, 0, nil ], *@cell_formats ].map { |format, font, fill, border, alignment| xf_xml(format, font, fill, border, alignment) }
         xml = +%(#{DECLARATION}<styleSheet xmlns="#{MAIN_NS}">)
         xml << %(<numFmts count="#{formats.size}">#{formats.join}</numFmts>) unless formats.empty?
-        xml << %(<fonts count="2"><font>#{font}</font><font><b/>#{font}</font></fonts>)
-        xml << '<fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills>'
-        xml << '<borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders>'
+        xml << %(<fonts count="#{@fonts.size}">#{@fonts.keys.map { font_xml(*_1) }.join}</fonts>)
+        xml << %(<fills count="#{@fills.size}">#{@fills.keys.map { fill_xml(_1) }.join}</fills>)
+        xml << %(<borders count="#{@borders.size}">#{@borders.keys.map { border_xml(_1) }.join}</borders>)
         xml << '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>'
         xml << %(<cellXfs count="#{xfs.size}">#{xfs.join}</cellXfs>)
         xml << '<cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>'
       end
 
+      def xf_xml(format, font, fill, border, alignment)
+        attributes = %(numFmtId="#{format}" fontId="#{font}" fillId="#{fill}" borderId="#{border}" xfId="0")
+        attributes += ' applyNumberFormat="1"' unless format.zero?
+        attributes += ' applyFont="1"' unless font.zero?
+        attributes += ' applyFill="1"' unless fill.zero?
+        attributes += ' applyBorder="1"' unless border.zero?
+        alignment ? %(<xf #{attributes} applyAlignment="1">#{alignment}</xf>) : "<xf #{attributes}/>"
+      end
+
+      def font_xml(bold, italic, size, color)
+        xml = +"<font>"
+        xml << "<b/>" if bold
+        xml << "<i/>" if italic
+        xml << %(<sz val="#{number_text(size || 11)}"/>)
+        xml << %(<color rgb="FF#{color}"/>) if color
+        xml << '<name val="Calibri"/><family val="2"/></font>'
+      end
+
+      def fill_xml(key)
+        case key
+        when nil then '<fill><patternFill patternType="none"/></fill>'
+        when :gray125 then '<fill><patternFill patternType="gray125"/></fill>'
+        else %(<fill><patternFill patternType="solid"><fgColor rgb="FF#{key}"/><bgColor indexed="64"/></patternFill></fill>)
+        end
+      end
+
+      def border_xml(border)
+        edges = %i[left right top bottom].map do |edge|
+          next "<#{edge}/>" unless border&.edges&.include?(edge)
+
+          %(<#{edge} style="#{border.style}"><color rgb="FF#{border.color}"/></#{edge}>)
+        end
+        "<border>#{edges.join}<diagonal/></border>"
+      end
+
       def workbook_xml
         sheets = @sheet_names.each_with_index.map do |name, index|
           %(<sheet name="#{XmlText.escape(name)}" sheetId="#{index + 1}" r:id="rId#{index + 1}"/>)
         end
         %(#{DECLARATION}<workbook xmlns="#{MAIN_NS}" xmlns:r="#{REL_NS}"><bookViews><workbookView activeTab="0"/></bookViews>) +
-          "<sheets>#{sheets.join}</sheets></workbook>"
+          "<sheets>#{sheets.join}</sheets>#{'<calcPr fullCalcOnLoad="1"/>' if @formulas}</workbook>"
       end
 
       def workbook_relationships_xml

data/lib/calcsheet/writers/zip_buffered.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "tempfile"
 require_relative "../grid"
 
 module Calcsheet
@@ -36,10 +37,28 @@ module Calcsheet
       end
 
       def flush
-        @entry << @buffer
+        @deferred ? @deferred.write(@buffer) : @entry << @buffer
         @buffer.clear
       end
 
+      # From now on the flushed rows go to a temporary file (+auto_width+: what precedes them is known only after
+      # them), until #replay_deferred. A Tempfile: one left behind by a book whose block raised is deleted when it is
+      # collected.
+      def defer_rows
+        @deferred = Tempfile.new("calcsheet-rows", binmode: true)
+      end
+
+      # Writes the deferred rows to the entry and deletes the file.
+      def replay_deferred
+        file = @deferred
+        @deferred = nil
+        file.rewind
+        chunk = String.new(capacity: BUFFER_SIZE)
+        @entry << chunk while file.read(BUFFER_SIZE, chunk)
+      ensure
+        file&.close!
+      end
+
       # The sheet of a book whose block wrote none.
       def empty_book_sheet
         start_sheet(EMPTY_BOOK_SHEET, [], header: false)

data/lib/calcsheet.rb

@@ -28,13 +28,19 @@ require_relative "calcsheet/readers/xlsx/workbook_meta"
 require_relative "calcsheet/readers/xlsx/shared_strings"
 require_relative "calcsheet/readers/xlsx_reader"
 require_relative "calcsheet/readers/ods_reader"
+require_relative "calcsheet/native_backends"
 require_relative "calcsheet/column"
+require_relative "calcsheet/formula"
+require_relative "calcsheet/cell_range"
+require_relative "calcsheet/display_format"
+require_relative "calcsheet/style"
 require_relative "calcsheet/sheet_names"
 require_relative "calcsheet/write_sheet"
 require_relative "calcsheet/write_book"
 require_relative "calcsheet/stream_body"
 require_relative "calcsheet/writers/csv_writer"
 require_relative "calcsheet/writers/xml_text"
+require_relative "calcsheet/writers/open_formula"
 require_relative "calcsheet/writers/xlsx_writer"
 require_relative "calcsheet/writers/ods_writer"
 
@@ -45,14 +51,22 @@ require_relative "calcsheet/writers/ods_writer"
 module Calcsheet
   # The formats Calcsheet.write infers from the extension of a path.
   WRITE_EXTENSIONS = { ".csv" => :csv, ".xlsx" => :xlsx, ".ods" => :ods }.freeze
+  # @api private
+  # calcsheet's own reader backends by format: the initial Calcsheet.backends, and the readers calcsheet-native
+  # replaces (NativeBackends).
+  RUBY_BACKENDS = { csv: Readers::CsvReader, xlsx: Readers::XlsxReader, ods: Readers::OdsReader }.freeze
 
   class << self
     # The reader backends by format (see Reading for their contract). A mutable registry: an application may add or
     # replace a backend before it opens files (+Calcsheet.backends[:tsv] = MyReader+). Detection only ever answers
     # +:csv+, +:xlsx+ or +:ods+, so a backend under another key is used only with an explicit +format:+.
+    #
+    # The registry holds the Ruby backends: calcsheet-native, when it is installed and compatible, reads in place of
+    # calcsheet's own readers under +backend: :auto+ (the default) and +:native+ (see Book#backend). A backend an
+    # application registered is never replaced (+backend: :native+ refuses its format).
     # @return [Hash{Symbol => Class}]
     def backends
-      @backends ||= { csv: Readers::CsvReader, xlsx: Readers::XlsxReader, ods: Readers::OdsReader }
+      @backends ||= RUBY_BACKENDS.dup
     end
 
     # Opens a spreadsheet for reading. With a block, yields the book, closes it afterwards and returns the
@@ -65,7 +79,9 @@ module Calcsheet
     #   caller is never closed
     # @param format [Symbol, String, nil] a key of Calcsheet.backends, which skips detection; nil detects +:csv+,
     #   +:xlsx+ or +:ods+ from the content (the extension only breaks a tie)
-    # @param options [Hash] Options overrides for this book (any key of Configuration::DEFAULTS)
+    # @param options [Hash] Options overrides for this book (any key of Configuration::DEFAULTS); +backend:+ chooses
+    #   the reader: +:auto+ calcsheet-native when it is installed and compatible, else the Ruby backend; +:ruby+ the
+    #   backend of Calcsheet.backends; +:native+ calcsheet-native or BackendUnavailableError
     # @yieldparam book [Book]
     # @return [Object, Book] the block's value with a block; the open book without one
     # @raise [ArgumentError] an unknown or invalid option, a source that is neither a path nor an IO, or a +format:+
@@ -75,6 +91,8 @@ module Calcsheet
     #   it is read instead)
     # @raise [UnsupportedFormatError] an XLS or encrypted (OLE2) file, a zip that is neither XLSX nor ODS, an encrypted
     #   or unsupported zip entry, or a +format:+ without a backend
+    # @raise [BackendUnavailableError] +backend: :native+ and calcsheet-native cannot read the book (not installed, an
+    #   unsupported protocol, a format it does not read, or an application's own backend for the format)
     # @raise [MalformedFileError] a damaged zip archive or workbook part
     # @raise [ZipBombError] the archive has more entries than +max_zip_entries+, or reading its workbook parts
     #   exceeds a zip limit
@@ -82,12 +100,12 @@ module Calcsheet
     #   raises it, at the first Book#sheets or read)
     def open(source, format: nil, **options)
       options = config.options(**options)
-      backend_class = format && backend_for(format)
-      input = Source.open(source, options, needs_seek: backend_class.nil? || backend_class.needs_seek?)
+      selected = format && select_backend(format, options.backend)
+      input = Source.open(source, options, needs_seek: selected.nil? || selected.first.needs_seek?)
       begin
         format = format.nil? ? FormatDetector.detect(input.io, path: input.path, max_zip_entries: options.max_zip_entries) : format.to_sym
-        backend_class ||= backend_for(format)
-        book = Book.new(backend_class.new(input, options), format: format, options: options, source: input)
+        backend_class, backend = selected || select_backend(format, options.backend)
+        book = Book.new(backend_class.new(input, options), format: format, options: options, source: input, backend: backend)
       # Exception, not StandardError: an Interrupt or a timeout during detection must also close the Source,
       # which deletes the Tempfile copy of a non-seekable stream (as Source#initialize does).
       rescue Exception # rubocop:disable Lint/RescueException
@@ -287,9 +305,14 @@ module Calcsheet
       raise ArgumentError, "format: expected a Symbol or a String, got #{format.inspect}"
     end
 
-    def backend_for(format)
+    # @param mode [Symbol] the +backend:+ option
+    # @return [Array(Class, Symbol)] the backend class of +format+ and +:ruby+ or +:native+ (Book#backend)
+    def select_backend(format, mode)
       check_format_type(format)
-      backends.fetch(format.to_sym) { raise UnsupportedFormatError, "no reader for format #{format.to_sym.inspect}" }
+      format = format.to_sym
+      backend_class = backends.fetch(format) { raise UnsupportedFormatError, "no reader for format #{format.inspect}" }
+      native = NativeBackends.backend_for(format, mode) unless mode == :ruby
+      native ? [ native, :native ] : [ backend_class, :ruby ]
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: calcsheet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Demetra Opinioni.net Srl
@@ -101,19 +101,23 @@ files:
 - lib/calcsheet.rb
 - lib/calcsheet/book.rb
 - lib/calcsheet/cast.rb
+- lib/calcsheet/cell_range.rb
 - lib/calcsheet/column.rb
 - lib/calcsheet/column_letter.rb
 - lib/calcsheet/configuration.rb
 - lib/calcsheet/decimal_text.rb
+- lib/calcsheet/display_format.rb
 - lib/calcsheet/entry_name.rb
 - lib/calcsheet/errors.rb
 - lib/calcsheet/excel_serial.rb
 - lib/calcsheet/format_detector.rb
+- lib/calcsheet/formula.rb
 - lib/calcsheet/formula_protection.rb
 - lib/calcsheet/grid.rb
 - lib/calcsheet/header_keys.rb
 - lib/calcsheet/limited_inflater.rb
 - lib/calcsheet/merge_check.rb
+- lib/calcsheet/native_backends.rb
 - lib/calcsheet/odf.rb
 - lib/calcsheet/option_validation.rb
 - lib/calcsheet/options.rb
@@ -122,6 +126,7 @@ files:
 - lib/calcsheet/readers/csv_dialect.rb
 - lib/calcsheet/readers/csv_input.rb
 - lib/calcsheet/readers/csv_reader.rb
+- lib/calcsheet/readers/csv_records.rb
 - lib/calcsheet/readers/ods/cell_formats.rb
 - lib/calcsheet/readers/ods/content_parser.rb
 - lib/calcsheet/readers/ods/count.rb
@@ -149,13 +154,16 @@ files:
 - lib/calcsheet/readers/xlsx_reader.rb
 - lib/calcsheet/reading.rb
 - lib/calcsheet/row.rb
+- lib/calcsheet/row_builder.rb
 - lib/calcsheet/sample.rb
 - lib/calcsheet/schema.rb
 - lib/calcsheet/sheet_info.rb
+- lib/calcsheet/sheet_list.rb
 - lib/calcsheet/sheet_names.rb
 - lib/calcsheet/sheet_selection.rb
 - lib/calcsheet/source.rb
 - lib/calcsheet/stream_body.rb
+- lib/calcsheet/style.rb
 - lib/calcsheet/time_zone.rb
 - lib/calcsheet/untrusted.rb
 - lib/calcsheet/version.rb
@@ -163,6 +171,7 @@ files:
 - lib/calcsheet/write_sheet.rb
 - lib/calcsheet/writers/csv_writer.rb
 - lib/calcsheet/writers/ods_writer.rb
+- lib/calcsheet/writers/open_formula.rb
 - lib/calcsheet/writers/xlsx_writer.rb
 - lib/calcsheet/writers/xml_text.rb
 - lib/calcsheet/writers/zip_buffered.rb
@@ -194,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Streaming CSV, XLSX and ODS reader and writer.
 test_files: []