xlsxrb 0.1.14 → 0.1.16

data/lib/xlsxrb/ooxml/workbook_writer.rb

@@ -93,6 +93,9 @@ module Xlsxrb
               selection: sheet[:selection],
               sheet_view: sheet[:sheet_view],
               sheet_properties: sheet[:sheet_properties],
+              sheet_format: sheet[:sheet_format],
+              protected_ranges: sheet[:protected_ranges],
+              cell_watches: sheet[:cell_watches],
               tables: sheet_tables,
               table_start_rid: info[:table_start_rid],
               legacy_drawing_rid: info[:vml_rid],
@@ -493,6 +496,14 @@ module Xlsxrb
           b.empty_tag("workbookProtection", wp_attrs) unless wp_attrs.empty?
         end
 
+        # Workbook view: which sheet tab is selected when the file is opened
+        active_tab = @workbook_properties&.[](:active_tab)
+        if active_tab
+          b.open_tag("bookViews")
+          b.empty_tag("workbookView", { activeTab: active_tab.to_s })
+          b.close_tag("bookViews")
+        end
+
         b.open_tag("sheets")
         @sheets.each_with_index do |sheet, idx|
           s_name = sheet.respond_to?(:name) ? sheet.name : sheet[:name]
@@ -528,6 +539,9 @@ module Xlsxrb
           b.close_tag("definedNames")
         end
 
+        # Calculation properties: ask Excel to recalculate every formula when the file is opened
+        b.empty_tag("calcPr", { fullCalcOnLoad: "1" }) if @workbook_properties&.[](:full_calc_on_load)
+
         # Pivot caches
         total_pivots = @sheets.sum { |s| (s[:pivot_tables] || []).size }
         if total_pivots.positive?
@@ -594,7 +608,11 @@ module Xlsxrb
         b.open_tag("styleSheet", { xmlns: SSML_NS })
 
         # Number formats
-        raw_num_fmts = @styles&.dig(:num_fmts) || []
+        raw_num_fmts = if @styles.respond_to?(:num_fmts)
+                         @styles.num_fmts
+                       else
+                         @styles&.dig(:num_fmts) || []
+                       end
         num_fmts = if raw_num_fmts.is_a?(Hash)
                      raw_num_fmts.map { |k, v| { num_fmt_id: k.to_i, format_code: v.to_s } }
                    elsif raw_num_fmts.is_a?(Array)
@@ -619,7 +637,11 @@ module Xlsxrb
         end
 
         # Fonts
-        fonts = @styles&.dig(:fonts) || []
+        fonts = if @styles.respond_to?(:fonts)
+                  @styles.fonts
+                else
+                  @styles&.dig(:fonts) || []
+                end
         fonts = [{}] if fonts.empty? # At least one default font
         b.tag("fonts", { count: fonts.size.to_s }) do |_|
           fonts.each do |font_props|
@@ -631,14 +653,19 @@ module Xlsxrb
                 b.empty_tag("u", font_props[:underline] == "single" ? {} : { val: font_props[:underline] })
               end
               b.empty_tag("sz", { val: (font_props[:sz] || 11).to_s }) if font_props[:sz] || fonts == [{}]
-              b.empty_tag("color", { rgb: font_props[:color] }) if font_props[:color]
+              color_attrs = color_tag_attrs(font_props[:color] || (font_props.key?(:rgb) || font_props.key?(:theme) || font_props.key?(:indexed) ? font_props : nil))
+              b.empty_tag("color", color_attrs) if color_attrs
               b.empty_tag("name", { val: font_props[:name] || "Calibri" })
             end
           end
         end
 
         # Fills
-        fills = @styles&.dig(:fills) || []
+        fills = if @styles.respond_to?(:fills)
+                  @styles.fills
+                else
+                  @styles&.dig(:fills) || []
+                end
         fills = [{ pattern: "none" }, { pattern: "gray125" }] if fills.empty?
         b.tag("fills", { count: fills.size.to_s }) do |_|
           fills.each do |fill_props|
@@ -647,14 +674,18 @@ module Xlsxrb
                 b.open_tag("gradientFill", { type: fill_props[:gradient][:type], degree: fill_props[:gradient][:degree]&.to_s }.compact)
                 fill_props[:gradient][:stops].each do |stop|
                   b.tag("stop", { position: stop[:position].to_s }) do |_|
-                    b.empty_tag("color", { rgb: stop[:color] })
+                    c_attrs = color_tag_attrs(stop[:color] || stop)
+                    b.empty_tag("color", c_attrs) if c_attrs
                   end
                 end
                 b.close_tag("gradientFill")
               else
                 b.tag("patternFill", { patternType: fill_props[:pattern] || "none" }) do |_|
-                  b.empty_tag("fgColor", { rgb: fill_props[:fg_color] }) if fill_props[:fg_color]
-                  b.empty_tag("bgColor", { rgb: fill_props[:bg_color] }) if fill_props[:bg_color]
+                  fg_attrs = color_tag_attrs(fill_props[:fg_color] || (fill_props[:fg_color_theme] ? { theme: fill_props[:fg_color_theme], tint: fill_props[:fg_color_tint] } : nil) || (fill_props[:fg_color_indexed] ? { indexed: fill_props[:fg_color_indexed] } : nil))
+                  b.empty_tag("fgColor", fg_attrs) if fg_attrs
+
+                  bg_attrs = color_tag_attrs(fill_props[:bg_color] || (fill_props[:bg_color_theme] ? { theme: fill_props[:bg_color_theme], tint: fill_props[:bg_color_tint] } : nil) || (fill_props[:bg_color_indexed] ? { indexed: fill_props[:bg_color_indexed] } : nil))
+                  b.empty_tag("bgColor", bg_attrs) if bg_attrs
                 end
               end
             end
@@ -662,7 +693,11 @@ module Xlsxrb
         end
 
         # Borders
-        borders = @styles&.dig(:borders) || []
+        borders = if @styles.respond_to?(:borders)
+                    @styles.borders
+                  else
+                    @styles&.dig(:borders) || []
+                  end
         borders = [{}] if borders.empty?
         b.tag("borders", { count: borders.size.to_s }) do |_|
           borders.each do |border_props|
@@ -674,16 +709,8 @@ module Xlsxrb
                 side_data = border_props[side]
                 if side_data
                   b.tag(side.to_s, { style: side_data[:style] }) do |_|
-                    c = side_data[:color]
-                    if c.is_a?(Hash)
-                      c_attrs = {}
-                      c_attrs[:rgb] = c[:rgb] if c[:rgb]
-                      c_attrs[:theme] = c[:theme].to_s if c[:theme]
-                      c_attrs[:tint] = c[:tint].to_s if c[:tint]
-                      b.empty_tag("color", c_attrs) unless c_attrs.empty?
-                    elsif c
-                      b.empty_tag("color", { rgb: c })
-                    end
+                    c_attrs = color_tag_attrs(side_data[:color])
+                    b.empty_tag("color", c_attrs) if c_attrs
                   end
                 else
                   b.empty_tag(side.to_s)
@@ -699,7 +726,11 @@ module Xlsxrb
         end
 
         # Cell XFs (formatting)
-        xf_entries = @styles&.dig(:cell_xfs) || @styles&.dig(:xf_entries) || []
+        xf_entries = if @styles.respond_to?(:cell_xfs)
+                       @styles.cell_xfs
+                     else
+                       @styles&.dig(:cell_xfs) || @styles&.dig(:xf_entries) || []
+                     end
         xf_count = [xf_entries.size, 1].max
         b.tag("cellXfs", { count: xf_count.to_s }) do |_|
           xf_entries.each do |xf|
@@ -748,7 +779,11 @@ module Xlsxrb
         end
 
         # Differential formats (for conditional formatting)
-        dxfs = @styles&.dig(:dxfs) || []
+        dxfs = if @styles.respond_to?(:dxfs)
+                 @styles.dxfs
+               else
+                 @styles&.dig(:dxfs) || []
+               end
         unless dxfs.empty?
           b.tag("dxfs", { count: dxfs.size.to_s }) do |_|
             dxfs.each do |dxf|
@@ -759,6 +794,9 @@ module Xlsxrb
                   b.empty_tag("numFmt", { numFmtId: nf[:num_fmt_id].to_s, formatCode: nf[:format_code].to_s })
                 end
                 write_dxf_fill(b, dxf[:fill]) if dxf[:fill]
+                write_dxf_alignment(b, dxf[:alignment]) if dxf[:alignment]
+                write_dxf_border(b, dxf[:border]) if dxf[:border]
+                write_dxf_protection(b, dxf[:protection]) if dxf[:protection]
               end
             end
           end
@@ -769,8 +807,6 @@ module Xlsxrb
       end
 
       def preprocess_conditional_formats!
-        @styles[:dxfs] ||= []
-
         @sheets.each do |sheet|
           rules = sheet[:conditional_formats]
           next if rules.nil? || rules.empty?
@@ -782,11 +818,15 @@ module Xlsxrb
             dxf = normalized.delete(:dxf) || extract_dxf_from_rule!(normalized)
             next normalized unless dxf
 
-            dxf_id = @styles[:dxfs].index(dxf)
-            unless dxf_id
-              @styles[:dxfs] << dxf
-              dxf_id = @styles[:dxfs].size - 1
-            end
+            dxf_id = if @styles.respond_to?(:add_dxf)
+                       @styles.dxfs.index(dxf) || @styles.add_dxf(dxf)
+                     else
+                       @styles[:dxfs] ||= []
+                       @styles[:dxfs].index(dxf) || begin
+                         @styles[:dxfs] << dxf
+                         @styles[:dxfs].size - 1
+                       end
+                     end
             normalized[:format_id] = dxf_id
             normalized
           end
@@ -814,16 +854,24 @@ module Xlsxrb
 
       def write_dxf_font(builder, font)
         builder.tag("font") do |_|
-          builder.empty_tag("b") if font[:bold]
-          builder.empty_tag("i") if font[:italic]
+          if font.key?(:bold)
+            font[:bold] ? builder.empty_tag("b") : builder.empty_tag("b", { val: "0" })
+          end
+          if font.key?(:italic)
+            font[:italic] ? builder.empty_tag("i") : builder.empty_tag("i", { val: "0" })
+          end
+          if font.key?(:strike)
+            font[:strike] ? builder.empty_tag("strike") : builder.empty_tag("strike", { val: "0" })
+          end
           if font[:underline]
-            if font[:underline] == true
+            if [true, "single"].include?(font[:underline])
               builder.empty_tag("u")
             else
               builder.empty_tag("u", { val: font[:underline] })
             end
           end
-          builder.empty_tag("color", { rgb: font[:color] }) if font[:color]
+          color_attrs = color_tag_attrs(font[:color] || font)
+          builder.empty_tag("color", color_attrs) if color_attrs
           builder.empty_tag("name", { val: font[:name] }) if font[:name]
           builder.empty_tag("sz", { val: font[:sz].to_s }) if font[:sz]
         end
@@ -831,11 +879,120 @@ module Xlsxrb
 
       def write_dxf_fill(builder, fill)
         builder.tag("fill") do |_|
-          pattern = fill[:pattern] || "solid"
-          builder.tag("patternFill", { patternType: pattern }) do |_|
-            builder.empty_tag("fgColor", { rgb: fill[:fg_color] }) if fill[:fg_color]
-            builder.empty_tag("bgColor", { rgb: fill[:bg_color] }) if fill[:bg_color]
+          pattern_attrs = {}
+          pattern_attrs[:patternType] = fill[:pattern] if fill[:pattern]
+          builder.tag("patternFill", pattern_attrs) do |_|
+            fg_attrs = color_tag_attrs(fill[:fg_color])
+            builder.empty_tag("fgColor", fg_attrs) if fg_attrs
+            bg_attrs = color_tag_attrs(fill[:bg_color])
+            builder.empty_tag("bgColor", bg_attrs) if bg_attrs
+          end
+        end
+      end
+
+      def write_dxf_alignment(builder, alignment)
+        return if alignment.nil? || alignment.empty?
+
+        align_attrs = {}
+        align_attrs[:horizontal] = alignment[:horizontal] if alignment[:horizontal]
+        align_attrs[:vertical] = alignment[:vertical] if alignment[:vertical]
+        align_attrs[:wrapText] = "1" if alignment[:wrap_text]
+        align_attrs[:textRotation] = alignment[:text_rotation].to_s if alignment[:text_rotation]
+        align_attrs[:indent] = alignment[:indent].to_s if alignment[:indent]
+        align_attrs[:relativeIndent] = alignment[:relative_indent].to_s if alignment[:relative_indent]
+        align_attrs[:shrinkToFit] = "1" if alignment[:shrink_to_fit]
+        align_attrs[:readingOrder] = alignment[:reading_order].to_s if alignment[:reading_order]
+        align_attrs[:justifyLastLine] = "1" if alignment[:justify_last_line]
+        builder.empty_tag("alignment", align_attrs) unless align_attrs.empty?
+      end
+
+      def write_dxf_border(builder, border)
+        return if border.nil? || border.empty?
+
+        border_attrs = {}
+        border_attrs[:diagonalUp] = "1" if border[:diagonal_up]
+        border_attrs[:diagonalDown] = "1" if border[:diagonal_down]
+
+        builder.tag("border", border_attrs) do |_|
+          %i[left right top bottom diagonal].each do |side|
+            side_data = border[side]
+            next unless side_data
+
+            tag_attrs = {}
+            tag_attrs[:style] = side_data[:style] if side_data[:style]
+            c_attrs = color_tag_attrs(side_data[:color])
+            if c_attrs
+              builder.tag(side.to_s, tag_attrs) do |_|
+                builder.empty_tag("color", c_attrs)
+              end
+            elsif !tag_attrs.empty?
+              builder.empty_tag(side.to_s, tag_attrs)
+            else
+              builder.empty_tag(side.to_s)
+            end
+          end
+        end
+      end
+
+      def write_dxf_protection(builder, protection)
+        return if protection.nil? || protection.empty?
+
+        prot_attrs = {}
+        prot_attrs[:locked] = protection[:locked] ? "1" : "0" unless protection[:locked].nil?
+        prot_attrs[:hidden] = protection[:hidden] ? "1" : "0" unless protection[:hidden].nil?
+        builder.empty_tag("protection", prot_attrs) unless prot_attrs.empty?
+      end
+
+      # : (untyped rgb) -> ::String?
+      def format_rgb_hex(rgb)
+        return nil unless rgb
+
+        str = rgb.to_s.sub(/^#/, "").strip
+        return nil if str.empty?
+
+        case str
+        when /\A[0-9a-fA-F]{8}\z/
+          str.upcase
+        when /\A[0-9a-fA-F]{6}\z/
+          "FF#{str.upcase}"
+        when /\A[0-9a-fA-F]{3}\z/
+          r, g, b = str.chars
+          "FF#{r}#{r}#{g}#{g}#{b}#{b}".upcase
+        else
+          resolved = StyleBuilder.resolve_color(rgb)
+          case resolved
+          when /\A[0-9a-fA-F]{8}\z/
+            resolved.upcase
+          when /\A[0-9a-fA-F]{6}\z/
+            "FF#{resolved.upcase}"
+          end
+        end
+      end
+
+      # : (untyped spec) -> ::Hash[Symbol, ::String]?
+      def color_tag_attrs(spec)
+        return nil unless spec
+
+        spec = spec[:color] if spec.is_a?(Hash) && spec[:color].is_a?(Hash)
+        return nil unless spec
+
+        if spec.is_a?(Hash)
+          if spec[:auto]
+            { auto: "1" }
+          elsif spec[:rgb] || (spec[:color] && !spec[:color].is_a?(Hash))
+            raw_rgb = spec[:rgb] || spec[:color]
+            fmt = format_rgb_hex(raw_rgb)
+            fmt ? { rgb: fmt } : nil
+          elsif spec[:theme]
+            attrs = { theme: spec[:theme].to_s }
+            attrs[:tint] = spec[:tint].to_s if spec[:tint]
+            attrs
+          elsif spec[:indexed]
+            { indexed: spec[:indexed].to_s }
           end
+        elsif spec.is_a?(String) || spec.is_a?(Symbol)
+          fmt = format_rgb_hex(spec)
+          fmt ? { rgb: fmt } : nil
         end
       end
 
@@ -846,6 +1003,7 @@ module Xlsxrb
 
       def escape_xml(value)
         str = value.to_s
+        str = str.dup.force_encoding(Encoding::UTF_8) if str.encoding == Encoding::BINARY
         str = str.gsub(INVALID_XML_CHARS_RE, "") if str.match?(INVALID_XML_CHARS_RE)
         str.match?(ESCAPE_RE) ? str.gsub(ESCAPE_RE, ESCAPE_MAP) : str
       end
@@ -878,11 +1036,10 @@ module Xlsxrb
                 end
                 buf << '<vertAlign val="' << font[:vert_align].to_s << '"/>' if font[:vert_align]
                 buf << '<sz val="' << font[:sz].to_s << '"/>' if font[:sz]
-                if font[:color]
-                  buf << '<color rgb="' << font[:color].to_s << '"/>'
-                elsif font[:theme]
-                  tint_attr = font[:tint] ? " tint=\"#{font[:tint]}\"" : ""
-                  buf << '<color theme="' << font[:theme].to_s << '"' << tint_attr << "/>"
+                color_attrs = color_tag_attrs(font[:color] || font)
+                if color_attrs
+                  attrs_str = color_attrs.map { |k, v| %(#{k}="#{v}") }.join(" ")
+                  buf << "<color #{attrs_str}/>"
                 end
                 buf << '<rFont val="' << escape_xml(font[:name]) << '"/>' if font[:name]
                 buf << '<family val="' << font[:family].to_s << '"/>' if font[:family]
@@ -891,17 +1048,11 @@ module Xlsxrb
               else
                 buf << "<r><t>"
               end
-              buf << escape_xml(run[:text]) << "</t></r>"
+              buf << escape_xml(run[:text].to_s) << "</t></r>"
             end
             buf << "</si>"
           else
-            s = str.to_s
-            needs_space = s.start_with?(" ", "\t", "\n") || s.end_with?(" ", "\t", "\n")
-            if needs_space
-              buf << '<si><t xml:space="preserve">' << escape_xml(s) << "</t></si>"
-            else
-              buf << "<si><t>" << escape_xml(s) << "</t></si>"
-            end
+            buf << "<si><t>" << escape_xml(str.to_s) << "</t></si>"
           end
 
           if buf.bytesize >= 32_768
@@ -917,14 +1068,14 @@ module Xlsxrb
       end
 
       def write_worksheet_xml(io, sheet, drawing_rid: nil, sheet_protection: nil,
-                              auto_filter: nil, filter_columns: nil, sort_state: nil,
-                              merge_cells: nil, conditional_formats: nil,
+                              protected_ranges: nil, auto_filter: nil, filter_columns: nil,
+                              sort_state: nil, merge_cells: nil, conditional_formats: nil,
                               data_validations: nil, hyperlinks: nil,
                               print_options: nil, page_margins: nil, page_setup: nil,
                               header_footer: nil, row_breaks: nil, col_breaks: nil,
-                              freeze_pane: nil, split_pane: nil, selection: nil,
-                              sheet_view: nil, sheet_properties: nil,
-                              tables: nil, table_start_rid: nil,
+                              cell_watches: nil, freeze_pane: nil, split_pane: nil,
+                              selection: nil, sheet_view: nil, sheet_properties: nil,
+                              sheet_format: nil, tables: nil, table_start_rid: nil,
                               legacy_drawing_rid: nil, sparkline_groups: nil)
         date1904 = @workbook_properties&.[](:date1904) ? true : false
         ws = WorksheetWriter.new(io, date1904: date1904)
@@ -934,7 +1085,8 @@ module Xlsxrb
           freeze_pane: freeze_pane,
           split_pane: split_pane,
           selection: selection,
-          sheet_view: sheet_view
+          sheet_view: sheet_view,
+          sheet_format: sheet_format
         )
         if sheet[:rows_tmp_path]
           File.open(sheet[:rows_tmp_path], "rb") do |f|
@@ -961,6 +1113,7 @@ module Xlsxrb
         ws.finish(
           drawing_rid: drawing_rid,
           sheet_protection: sheet_protection,
+          protected_ranges: protected_ranges,
           auto_filter: auto_filter,
           filter_columns: filter_columns,
           sort_state: sort_state,
@@ -974,6 +1127,7 @@ module Xlsxrb
           header_footer: header_footer,
           row_breaks: row_breaks,
           col_breaks: col_breaks,
+          cell_watches: cell_watches,
           tables: tables,
           table_start_rid: table_start_rid,
           legacy_drawing_rid: legacy_drawing_rid,
@@ -1002,8 +1156,25 @@ module Xlsxrb
         # Table columns
         columns = tbl[:columns] || []
         b.open_tag("tableColumns", { count: columns.size.to_s })
-        columns.each_with_index do |col_name, ci|
-          b.empty_tag("tableColumn", { id: (ci + 1).to_s, name: col_name })
+        columns.each_with_index do |col, ci|
+          col_name = col.is_a?(Hash) ? col[:name] : col
+          col_attrs = { id: (ci + 1).to_s, name: col_name.to_s }
+          if col.is_a?(Hash)
+            col_attrs[:totalsRowFunction] = col[:totals_row_function].to_s if col[:totals_row_function]
+            col_attrs[:totalsRowLabel] = col[:totals_row_label].to_s if col[:totals_row_label]
+            col_attrs[:dataDxfId] = col[:data_dxf_id].to_s if col[:data_dxf_id]
+            col_attrs[:totalsRowDxfId] = col[:totals_row_dxf_id].to_s if col[:totals_row_dxf_id]
+            col_attrs[:headerRowDxfId] = col[:header_row_dxf_id].to_s if col[:header_row_dxf_id]
+            col_attrs[:dataCellStyle] = col[:data_cell_style].to_s if col[:data_cell_style]
+          end
+          if col.is_a?(Hash) && (col[:calculated_column_formula] || col[:totals_row_formula])
+            b.open_tag("tableColumn", col_attrs)
+            b.tag("calculatedColumnFormula") { |cb| cb.text(col[:calculated_column_formula].to_s) } if col[:calculated_column_formula]
+            b.tag("totalsRowFormula") { |tb| tb.text(col[:totals_row_formula].to_s) } if col[:totals_row_formula]
+            b.close_tag("tableColumn")
+          else
+            b.empty_tag("tableColumn", col_attrs)
+          end
         end
         b.close_tag("tableColumns")
 
@@ -1102,11 +1273,13 @@ module Xlsxrb
         @custom_properties.each_with_index do |prop, idx|
           b.open_tag("property", { fmtid: "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}", pid: (idx + 2).to_s, name: prop[:name] })
           case prop[:type]
-          when :number
+          when :number, :int, :i4
             b.tag("vt:i4") { |_| b.text(prop[:value].to_s) }
-          when :bool
+          when :float, :r8
+            b.tag("vt:r8") { |_| b.text(prop[:value].to_s) }
+          when :bool, :boolean
             b.tag("vt:bool") { |_| b.text(prop[:value] ? "true" : "false") }
-          when :date
+          when :date, :filetime
             b.tag("vt:filetime") { |_| b.text(prop[:value].to_s) }
           else
             b.tag("vt:lpwstr") { |_| b.text(prop[:value].to_s) }