calcsheet 0.1.0 → 0.2.0

data/lib/calcsheet/writers/ods_writer.rb

@@ -7,8 +7,11 @@ require "zip_kit"
 require "zlib"
 require_relative "../decimal_text"
 require_relative "../errors"
+require_relative "../formula"
 require_relative "../grid"
 require_relative "../odf"
+require_relative "../style"
+require_relative "open_formula"
 require_relative "xml_text"
 require_relative "zip_buffered"
 
@@ -32,6 +35,12 @@ module Calcsheet
     # A :decimal cell with a +scale+ shows its value rounded half up to +scale+ decimals in its paragraph, as its number
     # style does; +office:value+ keeps the full value.
     #
+    # The Styles of the rows are common styles too, "Calcsheet1", "Calcsheet2"... one per Style and data style. A
+    # formula is translated to OpenFormula (OpenFormula.from_excel) and written without a value, which LibreOffice
+    # computes when it opens the file. A merge spans its first cell (+table:number-columns-spanned+,
+    # +table:number-rows-spanned+) and makes the others +table:covered-table-cell+ elements. With +auto_width+ a
+    # table's rows go to a temporary file until the sheet ends, since its columns come before them.
+    #
     # Text cells are +office:value-type="string"+, never evaluated, so "+39..." and "=..." stay verbatim.
     # A paragraph collapses white space (ODF 1.3 part 3, §6.1.2), and the ODS reader too: a run of spaces after a
     # character is written as one space and a +text:s+ for the rest, other spaces (leading, after a tab or a line
@@ -81,8 +90,9 @@ module Calcsheet
       VERSION = "1.3"
       DECLARATION = %(<?xml version="1.0" encoding="UTF-8"?>\n)
       # The namespaces the root elements declare. LibreOffice resolves the prefix of the "ooo:view-settings" name:
-      # without ooo, it ignores the view settings.
-      NAMESPACES = Odf::NAMESPACES.slice(:office, :style, :text, :table, :fo, :number, :config, :ooo).freeze
+      # without ooo, it ignores the view settings. "of" is the prefix of the formulas.
+      NAMESPACES = Odf::NAMESPACES.slice(:office, :style, :text, :table, :fo, :number, :config, :ooo)
+                                  .merge(of: "urn:oasis:names:tc:opendocument:xmlns:of:1.2").freeze
       MANIFEST_NS = "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
       # The namespace declarations and version of every root element.
       ROOT_ATTRIBUTES = "#{NAMESPACES.map { |prefix, uri| %(xmlns:#{prefix}="#{uri}") }.join(" ")} office:version=\"#{VERSION}\"".freeze
@@ -156,26 +166,45 @@ module Calcsheet
         @buffer << content_start
         @sheets = []
         @styles = {}
+        @custom_styles = {}
+        @data_styles = {}
+        @deferred = nil
       end
 
-      # Starts the sheet's table in content.xml, with its columns and header row.
+      # Starts the sheet's table in content.xml, with its columns and header row; with +auto_width+, the rows go to a
+      # temporary file and the table is written when the sheet ends, its column widths known.
       # @raise [ArgumentError] for more columns than ODS holds
-      def start_sheet(name, columns, header:)
-        check_columns(name, columns, "ODS")
+      def start_sheet(name, columns, header:, widths: nil, auto_width: false)
+        check_columns(name, columns, "ODS") if columns
         @sheets << [ name, header ]
         @name = name
         @columns = columns
-        @types = columns.map(&:type)
+        @types = columns&.map(&:type)
         @row_number = 0
-        prepare_cells(columns)
-        @buffer << %(<table:table table:name="#{XmlText.escape(name)}">) << table_columns(columns)
+        @merges = []
+        prepare_cells(columns) if columns
+        if auto_width
+          flush
+          defer_rows
+        else
+          @buffer << table_start(columns ? columns.map(&:width) : widths || [])
+        end
         write_header(columns) if header
       end
 
-      # Writes one row of checked values (see the contract in WriteBook), consecutive empty cells as one repeated cell.
+      # @param range [CellRange] spanned by its first cell when its first row is written
+      def merge(range)
+        @merges << range
+      end
+
+      # Writes one row of checked values (see the contract in WriteBook), consecutive empty cells as one repeated cell:
+      # a typed row without styles, formulas or merges from the constant parts of #prepare_cells, any other cell by
+      # cell.
       # @raise [WriteError] for a year outside 1..9999; 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? || !@merges.empty? || values.any?(Formula)
+
         @buffer << "<table:table-row>"
         empty = 0
         index = 0
@@ -202,9 +231,19 @@ module Calcsheet
         raise
       end
 
-      # A table needs a row: a sheet without any gets an empty one.
-      def end_sheet
+      # A table needs a row: a sheet without any gets an empty one. With +auto_width+, writes the table's start and
+      # columns of +widths+, then its rows.
+      def end_sheet(widths = nil)
         @buffer << "<table:table-row>#{EMPTY_CELL}</table:table-row>" if @row_number.zero?
+        if @deferred
+          flush
+          file = @deferred
+          @deferred = nil
+          @buffer << table_start(widths || [])
+          flush
+          @deferred = file
+          replay_deferred
+        end
         @buffer << "</table:table>"
         flush
       end
@@ -226,7 +265,7 @@ module Calcsheet
       # @return [Array(Integer, String), nil] the column index and the reason
       def row_problem(values)
         values.each_with_index do |value, index|
-          next if value.nil? || !%i[date datetime].include?(@types[index]) || (value.year >= 1 && value.year <= 9999)
+          next if value.nil? || !%i[date datetime].include?(type_of(value, index)) || (value.year >= 1 && value.year <= 9999)
 
           return [ index, year_reason(value) ]
         end
@@ -240,9 +279,14 @@ module Calcsheet
           "</office:automatic-styles><office:body><office:spreadsheet>"
       end
 
+      def table_start(widths)
+        %(<table:table table:name="#{XmlText.escape(@name)}">#{table_columns(widths)})
+      end
+
       # One table-column per column, consecutive ones of the same width merged; a table needs one.
-      def table_columns(columns)
-        styles = columns.map { |column| column.width && %( table:style-name="co#{column.width.round.clamp(1, MAX_WIDTH)}") }
+      # @param widths [Array<Numeric, nil>] by column index
+      def table_columns(widths)
+        styles = widths.map { |width| width && %( table:style-name="co#{width.round.clamp(1, MAX_WIDTH)}") }
         return "<table:table-column/>" if styles.empty?
 
         styles.chunk_while { _1 == _2 }.map do |run|
@@ -317,6 +361,135 @@ module Calcsheet
         end
       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; a merge spans its first cell and covers
+      # the others.
+      def any_row(values, styles)
+        mark = @buffer.bytesize
+        row = @row_number + 1
+        merges = @merges.select { _1.first_row <= row && row <= _1.last_row }
+        count = [ values.size, styles&.size || 0, *merges.map { _1.last_column + 1 } ].max
+        @buffer << "<table:table-row>"
+        empty = 0
+        index = 0
+        while index < count
+          value = values[index]
+          style = styles&.[](index)
+          merge = merges.find { _1.cover?(row, index) }
+          first = merge && merge.first_row == row && merge.first_column == index
+          if value.nil? && style.nil? && merge.nil?
+            empty += 1
+          else
+            if empty.positive?
+              @buffer << empty_cells(empty)
+              empty = 0
+            end
+            if merge && !first
+              @buffer << "<table:covered-table-cell#{style_attribute(style, nil)}/>"
+            else
+              any_cell(value, index, style, first ? spans(merge) : "")
+            end
+          end
+          index += 1
+        end
+        @buffer << EMPTY_CELL if count.zero? || empty == count
+        @buffer << "</table:table-row>"
+        @row_number += 1
+        flush if @buffer.bytesize >= BUFFER_SIZE
+      rescue StandardError
+        rollback(mark)
+        raise
+      end
+
+      def spans(merge)
+        attributes = +""
+        columns = merge.last_column - merge.first_column + 1
+        rows = merge.last_row - merge.first_row + 1
+        attributes << %( table:number-columns-spanned="#{columns}") if columns > 1
+        attributes << %( table:number-rows-spanned="#{rows}") if rows > 1
+        attributes
+      end
+
+      def any_cell(value, index, style, spans)
+        type = value.nil? ? nil : type_of(value, index)
+        attributes = style_attribute(style, type && value_style(type, index)) + spans
+        case type
+        when nil then @buffer << "<table:table-cell#{attributes}/>"
+        when :formula
+          formula = XmlText.escape(OpenFormula.from_excel(value.text)).gsub(ATTRIBUTE_BREAKS, ATTRIBUTE_SPACE)
+          @buffer << "<table:table-cell#{attributes} table:formula=\"#{formula}\"/>"
+        when :string then text_cell(%(<table:table-cell#{attributes} office:value-type="string"), value)
+        when :integer, :decimal
+          text = type == :integer ? value.to_s : DecimalText.plain(value)
+          value_type = style&.format&.kind == :percent ? "percentage" : "float"
+          @buffer << %(<table:table-cell#{attributes} office:value-type="#{value_type}" office:value="#{text}">) <<
+            "<text:p>" << text << CELL_END
+        when :date
+          check_year(value, index)
+          text = value.iso8601
+          @buffer << %(<table:table-cell#{attributes} office:value-type="date" office:date-value="#{text}"><text:p>) <<
+            text << CELL_END
+        when :datetime
+          check_year(value, index)
+          text = value.strftime("%Y-%m-%dT%H:%M:%S")
+          @buffer << %(<table:table-cell#{attributes} office:value-type="date" office:date-value="#{text}"><text:p>) <<
+            text.tr("T", " ") << CELL_END
+        else
+          text = value ? "true" : "false"
+          @buffer << %(<table:table-cell#{attributes} office:value-type="boolean" office:boolean-value="#{text}"><text:p>) <<
+            text.upcase << CELL_END
+        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 name of the data style a cell of +type+ takes without a style that gives one: its column's, or a date's,
+      # time's or boolean's.
+      def value_style(type, index)
+        if @columns && type != :formula
+          name = cell_style(@columns[index])
+          return name && "N#{name}"
+        end
+
+        case type
+        when :date then use_style(DATE_STYLE) && "N#{DATE_STYLE}"
+        when :datetime then use_style(DATETIME_STYLE) && "N#{DATETIME_STYLE}"
+        when :boolean then use_style(BOOLEAN_STYLE) && "N#{BOOLEAN_STYLE}"
+        end
+      end
+
+      # The table:style-name attribute of a cell: a common style for its Style with its data style (the Style's
+      # format, else +value_style+), the plain data style's cell style without a Style, nothing without either.
+      def style_attribute(style, data_style)
+        if style.nil?
+          return "" if data_style.nil?
+
+          return %( table:style-name="#{data_style.delete_prefix("N")}")
+        end
+
+        data_style = data_format(style.format) if style.format
+        name = @custom_styles[[ style, data_style ]] ||= "Calcsheet#{@custom_styles.size + 1}"
+        %( table:style-name="#{name}")
+      end
+
+      # The name of the data style of a DisplayFormat, registered at its first use.
+      def data_format(format)
+        @data_styles[format] ||= "NCalcsheet#{@data_styles.size + 1}"
+      end
+
       def number(text, index)
         @buffer << @openings[index] << text << VALUE_END << text << CELL_END
       end
@@ -375,7 +548,8 @@ module Calcsheet
       def check_year(value, index)
         return if value.year >= 1 && value.year <= 9999
 
-        raise WriteError.at(year_reason(value), sheet: @name, row: @row_number + 1, column_index: index, header: @columns[index].header)
+        raise WriteError.at(year_reason(value), sheet: @name, row: @row_number + 1, column_index: index,
+                                                header: @columns&.[](index)&.header)
       end
 
       def year_reason(value)
@@ -392,10 +566,69 @@ module Calcsheet
             %(<style:style style:name="#{name}" style:family="table-cell" style:data-style-name="N#{name}"/>)
           end
         end
+        data_styles.concat(@data_styles.map { |format, name| display_style(format, name) })
+        cell_styles.concat(@custom_styles.map { |(style, data_style), name| custom_style(style, data_style, name) })
         %(#{DECLARATION}<office:document-styles #{ROOT_ATTRIBUTES}><office:styles>#{data_styles.join}#{cell_styles.join}) +
           "</office:styles></office:document-styles>"
       end
 
+      # The ODF line of each border style, by its XLSX name.
+      BORDER_LINES = { thin: "0.75pt solid", medium: "1.5pt solid", thick: "2.5pt solid", dashed: "0.75pt dashed",
+                       dotted: "0.75pt dotted", double: "2.5pt double" }.freeze
+      # The ODF values of the alignments.
+      TEXT_ALIGN = { left: "start", center: "center", right: "end" }.freeze
+      VERTICAL_ALIGN = { top: "top", center: "middle", bottom: "bottom" }.freeze
+
+      def custom_style(style, data_style, name)
+        data = data_style ? %( style:data-style-name="#{data_style}") : ""
+        xml = +%(<style:style style:name="#{name}" style:family="table-cell" style:parent-style-name="Default"#{data}>)
+        cell = []
+        cell << %(fo:background-color="##{style.fill}") if style.fill
+        style.border&.edges&.each { cell << %(fo:border-#{_1}="#{BORDER_LINES.fetch(style.border.style)} ##{style.border.color}") }
+        cell << 'fo:wrap-option="wrap"' if style.wrap
+        cell << %(style:vertical-align="#{VERTICAL_ALIGN.fetch(style.valign)}") if style.valign
+        xml << "<style:table-cell-properties #{cell.join(" ")}/>" unless cell.empty?
+        xml << %(<style:paragraph-properties fo:text-align="#{TEXT_ALIGN.fetch(style.align)}"/>) if style.align
+        text = []
+        text << 'fo:font-weight="bold" style:font-weight-asian="bold" style:font-weight-complex="bold"' if style.bold
+        text << 'fo:font-style="italic" style:font-style-asian="italic" style:font-style-complex="italic"' if style.italic
+        if style.size
+          size = "#{style.size}pt"
+          text << %(fo:font-size="#{size}" style:font-size-asian="#{size}" style:font-size-complex="#{size}")
+        end
+        text << %(fo:color="##{style.color}") if style.color
+        xml << "<style:text-properties #{text.join(" ")}/>" unless text.empty?
+        xml << "</style:style>"
+      end
+
+      # The data style of a DisplayFormat.
+      def display_style(format, name)
+        case format.kind
+        when :number then %(<number:number-style style:name="#{name}">#{number_element(format)}</number:number-style>)
+        when :percent
+          sign = format.code.end_with?(" %") ? " %" : "%"
+          %(<number:percentage-style style:name="#{name}">#{number_element(format)}<number:text>#{sign}</number:text></number:percentage-style>)
+        when :text then %(<number:text-style style:name="#{name}"><number:text-content/></number:text-style>)
+        else
+          element = format.kind == :time ? "number:time-style" : "number:date-style"
+          %(<#{element} style:name="#{name}">#{format.parts.map { date_part(*_1) }.join}</#{element}>)
+        end
+      end
+
+      def number_element(format)
+        grouping = format.grouping ? ' number:grouping="true"' : ""
+        %(<number:number number:decimal-places="#{format.decimals}" number:min-decimal-places="#{format.decimals}" ) +
+          %(number:min-integer-digits="1"#{grouping}/>)
+      end
+
+      def date_part(field, text)
+        case field
+        when :text then "<number:text>#{XmlText.escape(text)}</number:text>"
+        when :year then '<number:year number:style="long"/>'
+        else %(<number:#{field} number:style="long"/>)
+        end
+      end
+
       def data_style(name)
         case name
         when DATE_STYLE then %(<number:date-style style:name="N#{name}">#{DATE_PARTS}</number:date-style>)

data/lib/calcsheet/writers/open_formula.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Calcsheet
+  module Writers
+    # A formula in the syntax of Excel turned into OpenFormula, as ODS stores it: +SUM(B2:B5)+ becomes
+    # +of:=SUM([.B2:.B5])+. Cell references and ranges, on this sheet or another (+Data!A1+, +'My data'!A1:B2+),
+    # are bracketed, and the argument separator "," becomes ";"; strings, function names, numbers and operators are
+    # kept. Names and anything else stay as written.
+    #
+    # @api private
+    module OpenFormula
+      # A cell reference, with its optional "$" signs.
+      CELL = /\$?[A-Za-z]{1,3}\$?[1-9][0-9]{0,6}/
+      # A reference that is not the start of a longer name or a function call.
+      REFERENCE = /(#{CELL})(?::(#{CELL}))?(?![\w(.$:])/
+      # The sheet of a reference: a quoted name ('My data') or a plain one, before "!".
+      SHEET = /('(?:[^']|'')+'|[A-Za-z_][\w.]*)!/
+      # A string literal, its quotes doubled inside.
+      STRING = /"(?:[^"]|"")*"/
+      # A name or a function name.
+      NAME = /[A-Za-z_][\w.]*/
+
+      module_function
+
+      # @param text [String] the formula without its "=" (Formula#text)
+      # @return [String] the value of a cell's table:formula
+      def from_excel(text)
+        scanner = StringScanner.new(text)
+        result = +"of:="
+        until scanner.eos?
+          if (string = scanner.scan(STRING))
+            result << string
+          elsif scanner.check(SHEET) && (reference = sheet_reference(scanner))
+            result << reference
+          elsif scanner.scan(REFERENCE)
+            result << bracket(nil, scanner[1], scanner[2])
+          elsif (name = scanner.scan(NAME))
+            result << name
+          else
+            char = scanner.getch
+            result << (char == "," ? ";" : char)
+          end
+        end
+        result
+      end
+
+      # A reference with its sheet ("Data!A1"), or nil (the scanner unmoved) when no reference follows the sheet.
+      def sheet_reference(scanner)
+        start = scanner.pos
+        scanner.scan(SHEET)
+        sheet = scanner[1]
+        return bracket(sheet, scanner[1], scanner[2]) if scanner.scan(REFERENCE)
+
+        scanner.pos = start
+        nil
+      end
+
+      # "[.A1]", "[.A1:.B2]", "[$Data.A1]" or "[$'My data'.A1:.B2]".
+      def bracket(sheet, first, last)
+        prefix = sheet ? "$#{sheet}" : ""
+        last ? "[#{prefix}.#{first}:.#{last}]" : "[#{prefix}.#{first}]"
+      end
+    end
+  end
+end