xlsxrb 0.1.15 → 0.1.16

data/lib/xlsxrb/ooxml/worksheet_writer.rb

@@ -24,11 +24,14 @@ module Xlsxrb
         result.freeze
       end.freeze
 
-      INTEGER_STRINGS = (0..65_535).map(&:to_s).freeze
+      INTEGER_STRINGS = (0..65_535).map { |n| -n.to_s }.freeze
 
-      def initialize(io, date1904: false)
+      attr_accessor :escape_formulas
+
+      def initialize(io, date1904: false, escape_formulas: false)
         @io = io
         @date1904 = date1904 ? true : false
+        @escape_formulas = escape_formulas ? true : false
         @builder = XmlBuilder.new(@io)
         @row_buffer = String.new(capacity: 65_536)
         @started = false
@@ -59,12 +62,12 @@ module Xlsxrb
           columns.each do |col|
             if col.is_a?(Elements::Column)
               s = col.style_index
-              min = col.index
-              max = col.index
+              min = col.unmapped_data[:min] ? col.unmapped_data[:min] - 1 : col.index
+              max = col.unmapped_data[:max] ? col.unmapped_data[:max] - 1 : col.index
             else
               s = col[:style_index] || col[:style]
-              min = col[:index] || col[:min] || 0
-              max = col[:index] || col[:max] || col[:min] || 0
+              min = col[:min] ? col[:min] - 1 : (col[:index] || 0)
+              max = col[:max] ? col[:max] - 1 : (col[:index] || min)
             end
             next unless s
 
@@ -103,7 +106,7 @@ module Xlsxrb
         cells.each do |cell|
           if cell.is_a?(Elements::Cell)
             value = cell.value
-            style_id = cell.style_index
+            cell_style_id = cell.style_index
             col_ref = cell.ref || "#{column_letter(cell.column_index)}#{row_num_str}"
             col_idx = cell.column_index
             formula = cell.formula
@@ -111,7 +114,7 @@ module Xlsxrb
             cell_type_val = nil
           elsif cell.is_a?(Hash)
             value = cell[:value]
-            style_id = cell[:style_index]
+            cell_style_id = cell[:style_index]
             col_idx = cell[:column_index]
             col_ref = cell[:ref] || (col_idx ? "#{column_letter(col_idx)}#{row_num_str}" : nil)
             formula = cell[:formula]
@@ -119,7 +122,7 @@ module Xlsxrb
             cell_type_val = cell[:type]
           else
             value = cell
-            style_id = nil
+            cell_style_id = nil
             col_idx = nil
             col_ref = nil
             formula = nil
@@ -128,7 +131,7 @@ module Xlsxrb
           end
 
           col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
-          style_id ||= attrs[:style_index] || col_style
+          style_id = cell_style_id || attrs[:style_index] || col_style
           style_id = nil unless style_id.is_a?(Integer)
 
           # Fast path for common unstyled cells
@@ -138,7 +141,7 @@ module Xlsxrb
               buf << '<c r="' << col_ref << '"><v>' << value.to_s << "</v></c>"
               next
             when String
-              if !value.start_with?("=") && sst_index && (idx = sst_index[value])
+              if sst_index && (idx = sst_index[value])
                 buf << '<c r="' << col_ref << '" t="s"><v>' << idx.to_s << "</v></c>"
                 next
               end
@@ -159,17 +162,14 @@ module Xlsxrb
           end
 
           if value.nil? && formula.nil?
-            buf << '<c r="' << col_ref << '"'
-            buf << ' s="' << style_id.to_s << '"' if style_id
-            buf << "/>"
+            if cell_style_id.is_a?(Integer)
+              buf << '<c r="' << col_ref << '" s="' << cell_style_id.to_s << '"/>'
+            else
+              buf << '<c r="' << col_ref << '"/>'
+            end
             next
           end
 
-          if value.is_a?(String) && value.start_with?("=") && !formula
-            formula = value
-            value = nil
-          end
-
           xml_val = value
           type = cell_type_val
           formula_type = nil
@@ -183,22 +183,40 @@ module Xlsxrb
               formula_type = formula.type
               formula_ref = formula.ref
               formula_si = formula.shared_index
-              xml_val = formula.cached_value.nil? ? (value || nil) : formula.cached_value
+              xml_val = formula.cached_value.nil? ? value : formula.cached_value
             elsif formula.is_a?(Hash)
               formula_expr = formula[:formula] || formula[:expression]
               formula_ca = formula[:calculate_always]
               formula_type = formula[:type]
               formula_ref = formula[:ref]
               formula_si = formula[:si] || formula[:shared_index]
-              xml_val = formula[:value] || formula[:cached_value] || value || nil
+              xml_val = if formula.key?(:value)
+                          formula[:value]
+                        elsif formula.key?(:cached_value)
+                          formula[:cached_value]
+                        else
+                          value
+                        end
             else
               formula_expr = formula
-              xml_val = value || nil
+              xml_val = value
             end
-            formula_expr = formula_expr[1..] if formula_expr.start_with?("=")
+            formula_expr = formula_expr[1..] if formula_expr.is_a?(String) && formula_expr.start_with?("=")
           end
 
-          if !formula_expr && !type
+          if formula_expr
+            case xml_val
+            when true
+              type = "b"
+              xml_val = "1"
+            when false
+              type = "b"
+              xml_val = "0"
+            when Xlsxrb::Elements::CellError
+              type = "e"
+              xml_val = xml_val.code
+            end
+          elsif !type
             case value
             when String
               if sst_index && (idx = sst_index[value])
@@ -290,13 +308,18 @@ module Xlsxrb
             end
             f_attrs << ' ca="1"' if formula_ca
             buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
-            if xml_val
-              buf << "<v>" << xml_val.to_s << "</v></c>"
-            else
+            if xml_val.nil?
               buf << "<v>0</v></c>"
+            else
+              v_str = xml_val.to_s
+              v_str = v_str.dup.force_encoding(Encoding::UTF_8) if v_str.encoding == Encoding::BINARY
+              v_str = escape_xml(v_str) if type == "str" || xml_val.is_a?(String)
+              buf << "<v>" << v_str << "</v></c>"
             end
           else
-            buf << "><v>" << xml_val.to_s << "</v></c>"
+            v_str = xml_val.to_s
+            v_str = v_str.dup.force_encoding(Encoding::UTF_8) if v_str.encoding == Encoding::BINARY
+            buf << "><v>" << v_str << "</v></c>"
           end
         end
 
@@ -318,7 +341,7 @@ module Xlsxrb
         buf = @row_buffer ||= String.new(capacity: 65_536)
 
         if styles.nil? && attrs.nil? && @column_styles.nil?
-          buf << "<row r=\"#{row_num_str}\">"
+          buf << '<row r="' << row_num_str << '">'
           col_index = 0
           max_len = values.length
           while col_index < max_len
@@ -331,27 +354,26 @@ module Xlsxrb
             case value
             when Integer
               val_str = value >= 0 && value < 65_536 ? INTEGER_STRINGS[value] : value.to_s
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><v>#{val_str}</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '"><v>' << val_str << "</v></c>"
             when Float
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><v>#{value}</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '"><v>' << value.to_s << "</v></c>"
             when String
-              unless value.start_with?("=")
-                raise ArgumentError, "Cell text length #{value.length} exceeds Excel limit of 32,767 characters" if @strict_excel_mode && value.length > 32_767
+              raise ArgumentError, "Cell text length #{value.length} exceeds Excel limit of 32,767 characters" if @strict_excel_mode && value.length > 32_767
 
+              if sst_index
                 idx = (sst_index[value] ||= begin
                   sst << value
                   sst.size - 1
                 end)
                 idx_str = idx < 65_536 ? INTEGER_STRINGS[idx] : idx.to_s
-                buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"s\"><v>#{idx_str}</v></c>"
-                next
+                buf << '<c r="' << col_ref << row_num_str << '" t="s"><v>' << idx_str << "</v></c>"
+              else
+                buf << '<c r="' << col_ref << row_num_str << '" t="inlineStr"><is><t>' << escape_xml(value) << "</t></is></c>"
               end
-              formula_expr = value[1..]
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f><v>0</v></c>"
             when true
-              buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"b\"><v>1</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '" t="b"><v>1</v></c>'
             when false
-              buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"b\"><v>0</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '" t="b"><v>0</v></c>'
             when Date
               date_style_id = style_map ? style_map["__xlsxrb_date"] : nil
               buf << if date_style_id
@@ -382,8 +404,23 @@ module Xlsxrb
                 end
               end
               f_attrs << ' ca="1"' if value.calculate_always
-              v_val = value.cached_value.nil? ? 0 : value.cached_value
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{v_val}</v></c>"
+              c_type = ""
+              case value.cached_value
+              when true
+                c_type = ' t="b"'
+                v_val = "1"
+              when false
+                c_type = ' t="b"'
+                v_val = "0"
+              when Xlsxrb::Elements::CellError
+                c_type = ' t="e"'
+                v_val = value.cached_value.code
+              when nil
+                v_val = 0
+              else
+                v_val = value.cached_value.is_a?(String) ? escape_xml(value.cached_value) : value.cached_value
+              end
+              buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{v_val}</v></c>"
             when Hash
               if value.key?(:formula)
                 formula_expr = value[:formula] || value[:expression]
@@ -401,8 +438,27 @@ module Xlsxrb
                   end
                 end
                 f_attrs << ' ca="1"' if value[:calculate_always]
-                xml_val = value[:value] || value[:cached_value] || 0
-                buf << "<c r=\"#{col_ref}#{row_num_str}\"><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{xml_val}</v></c>"
+                xml_val = if value.key?(:value) && !value[:value].nil?
+                            value[:value]
+                          elsif value.key?(:cached_value) && !value[:cached_value].nil?
+                            value[:cached_value]
+                          else
+                            0
+                          end
+                c_type = ""
+                case xml_val
+                when true
+                  c_type = ' t="b"'
+                  xml_val = "1"
+                when false
+                  c_type = ' t="b"'
+                  xml_val = "0"
+                when Xlsxrb::Elements::CellError
+                  c_type = ' t="e"'
+                  xml_val = xml_val.code
+                end
+                xml_val = escape_xml(xml_val) if xml_val.is_a?(String)
+                buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{xml_val}</v></c>"
               end
             when Xlsxrb::Elements::CellError
               buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"e\"><v>#{value.code}</v></c>"
@@ -429,9 +485,17 @@ module Xlsxrb
         is_styles_collection = styles && (styles.is_a?(Array) || styles.is_a?(Hash))
         single_style_id = resolve_style_id(styles, style_map) unless is_styles_collection
 
+        row_style = attrs ? attrs[:style_index] : nil
+        row_style_id = resolve_style_id(row_style, style_map)
+
         buf << '<row r="' << row_num_str << '"'
+        buf << ' s="' << row_style_id.to_s << '" customFormat="1"' if row_style_id.is_a?(Integer)
         if attrs
-          buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"' if attrs[:height]
+          if attrs[:height]
+            buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"'
+          elsif attrs[:custom_height]
+            buf << ' customHeight="1"'
+          end
           buf << ' hidden="1"' if attrs[:hidden]
           buf << ' collapsed="1"' if attrs[:collapsed]
           buf << ' outlineLevel="' << attrs[:outline_level].to_s << '"' if attrs[:outline_level]
@@ -444,32 +508,31 @@ module Xlsxrb
           max_len = [max_len, styles_len].max
         end
 
-        row_style = attrs ? attrs[:style_index] : nil
-        row_style_id = resolve_style_id(row_style, style_map)
-
         col_index = 0
         while col_index < max_len
           value = col_index < values.length ? values[col_index] : nil
-          style_id = single_style_id
+          cell_style_id = single_style_id
           if is_styles_collection
             style_name = if styles.is_a?(Array)
                            col_index < styles.length ? styles[col_index] : nil
                          else
                            styles[col_index]
                          end
-            style_id = resolve_style_id(style_name, style_map)
+            cell_style_id = resolve_style_id(style_name, style_map)
           end
 
-          if style_id.nil?
+          if cell_style_id.nil?
             col_style = @column_styles ? @column_styles[col_index] : nil
             col_style_id = resolve_style_id(col_style, style_map)
             style_id = row_style_id || col_style_id
+          else
+            style_id = cell_style_id
           end
 
           col_ref = COLUMN_LETTERS[col_index] || column_letter(col_index)
 
           if value.nil?
-            buf << '<c r="' << col_ref << row_num_str << '" s="' << style_id.to_s << '"/>' if style_id
+            buf << '<c r="' << col_ref << row_num_str << '" s="' << cell_style_id.to_s << '"/>' if cell_style_id
             col_index += 1
             next
           end
@@ -487,7 +550,7 @@ module Xlsxrb
               col_index += 1
               next
             when String
-              unless value.start_with?("=")
+              if sst_index
                 idx = sst_index[value]
                 unless idx
                   sst << value
@@ -496,9 +559,11 @@ module Xlsxrb
                 end
                 idx_str = INTEGER_STRINGS[idx] || idx.to_s
                 buf << '<c r="' << col_ref << row_num_str << '" t="s"><v>' << idx_str << "</v></c>"
-                col_index += 1
-                next
+              else
+                buf << '<c r="' << col_ref << row_num_str << '" t="inlineStr"><is><t>' << escape_xml(value) << "</t></is></c>"
               end
+              col_index += 1
+              next
             when true
               buf << '<c r="' << col_ref << row_num_str << '" t="b"><v>1</v></c>'
               col_index += 1
@@ -544,6 +609,9 @@ module Xlsxrb
             when false
               type = "b"
               xml_val = "0"
+            when Xlsxrb::Elements::CellError
+              type = "e"
+              xml_val = value.cached_value.code
             end
           when Hash
             if value.key?(:formula)
@@ -552,7 +620,11 @@ module Xlsxrb
               formula_type = value[:type]
               formula_ref = value[:ref]
               formula_si = value[:si] || value[:shared_index]
-              xml_val = value[:value] || value[:cached_value]
+              xml_val = if value.key?(:value)
+                          value[:value]
+                        elsif value.key?(:cached_value)
+                          value[:cached_value]
+                        end
               case xml_val
               when String
                 type = "str"
@@ -562,26 +634,12 @@ module Xlsxrb
               when false
                 type = "b"
                 xml_val = "0"
+              when Xlsxrb::Elements::CellError
+                type = "e"
+                xml_val = xml_val.code
               end
             end
-          when String
-            if value.start_with?("=") && value.length > 1
-              formula_expr = value
-              xml_val = nil
-            elsif sst_index
-              idx = sst_index[value]
-              unless idx
-                sst << value
-                idx = sst.size - 1
-                sst_index[value] = idx
-              end
-              xml_val = idx
-              type = "s"
-            else
-              xml_val = value
-              type = "inlineStr"
-            end
-          when Xlsxrb::Elements::RichText
+          when String, Xlsxrb::Elements::RichText
             if sst_index
               idx = sst_index[value]
               unless idx
@@ -632,10 +690,12 @@ module Xlsxrb
             end
             f_attrs << ' ca="1"' if formula_ca
             buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
-            if xml_val
-              buf << "<v>" << xml_val.to_s << "</v></c>"
-            else
+            if xml_val.nil?
               buf << "<v>0</v></c>"
+            else
+              v_str = xml_val.to_s
+              v_str = escape_xml(v_str) if type == "str" || xml_val.is_a?(String)
+              buf << "<v>" << v_str << "</v></c>"
             end
           elsif type == "inlineStr"
             buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
@@ -733,12 +793,26 @@ module Xlsxrb
 
       def write_sheet_views(freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil)
         @builder.open_tag("sheetViews")
-        sv_attrs = { tabSelected: "1", workbookViewId: "0" }
+        sv_attrs = { workbookViewId: "0" }
         if sheet_view
-          sv_attrs[:showGridLines] = "0" if sheet_view[:show_grid_lines] == false
-          sv_attrs[:showRowColHeaders] = "0" if sheet_view[:show_row_col_headers] == false
-          sv_attrs[:rightToLeft] = "1" if sheet_view[:right_to_left]
+          sv_attrs[:windowProtection] = sheet_view[:window_protection] ? "1" : "0" unless sheet_view[:window_protection].nil?
+          sv_attrs[:showFormulas] = sheet_view[:show_formulas] ? "1" : "0" unless sheet_view[:show_formulas].nil?
+          sv_attrs[:showGridLines] = sheet_view[:show_grid_lines] ? "1" : "0" unless sheet_view[:show_grid_lines].nil?
+          sv_attrs[:showRowColHeaders] = sheet_view[:show_row_col_headers] ? "1" : "0" unless sheet_view[:show_row_col_headers].nil?
+          sv_attrs[:showZeros] = sheet_view[:show_zeros] ? "1" : "0" unless sheet_view[:show_zeros].nil?
+          sv_attrs[:rightToLeft] = sheet_view[:right_to_left] ? "1" : "0" unless sheet_view[:right_to_left].nil?
+          sv_attrs[:tabSelected] = "1" if sheet_view[:tab_selected]
+          sv_attrs[:showRuler] = sheet_view[:show_ruler] ? "1" : "0" unless sheet_view[:show_ruler].nil?
+          sv_attrs[:showOutlineSymbols] = sheet_view[:show_outline_symbols] ? "1" : "0" unless sheet_view[:show_outline_symbols].nil?
+          sv_attrs[:defaultGridColor] = sheet_view[:default_grid_color] ? "1" : "0" unless sheet_view[:default_grid_color].nil?
+          sv_attrs[:showWhiteSpace] = sheet_view[:show_white_space] ? "1" : "0" unless sheet_view[:show_white_space].nil?
+          sv_attrs[:view] = sheet_view[:view].to_s if sheet_view[:view]
+          sv_attrs[:topLeftCell] = sheet_view[:top_left_cell].to_s if sheet_view[:top_left_cell]
+          sv_attrs[:colorId] = sheet_view[:color_id].to_s if sheet_view[:color_id]
           sv_attrs[:zoomScale] = sheet_view[:zoom_scale].to_s if sheet_view[:zoom_scale]
+          sv_attrs[:zoomScaleNormal] = sheet_view[:zoom_scale_normal].to_s if sheet_view[:zoom_scale_normal]
+          sv_attrs[:zoomScaleSheetLayoutView] = sheet_view[:zoom_scale_sheet_layout_view].to_s if sheet_view[:zoom_scale_sheet_layout_view]
+          sv_attrs[:zoomScalePageLayoutView] = sheet_view[:zoom_scale_page_layout_view].to_s if sheet_view[:zoom_scale_page_layout_view]
         end
         @builder.open_tag("sheetView", sv_attrs)
         if freeze_pane
@@ -747,30 +821,38 @@ module Xlsxrb
           pane_attrs[:ySplit] = freeze_pane[:row].to_s if freeze_pane[:row]&.positive?
           top_left_col = column_letter(freeze_pane[:col] || 0)
           top_left_row = (freeze_pane[:row] || 0) + 1
-          pane_attrs[:topLeftCell] = "#{top_left_col}#{top_left_row}"
+          pane_attrs[:topLeftCell] = freeze_pane[:top_left_cell] || "#{top_left_col}#{top_left_row}"
           pane_attrs[:state] = "frozen"
           # Determine active pane
-          pane_attrs[:activePane] = if (freeze_pane[:col] || 0).positive? && (freeze_pane[:row] || 0).positive?
-                                      "bottomRight"
-                                    elsif (freeze_pane[:col] || 0).positive?
-                                      "topRight"
-                                    else
-                                      "bottomLeft"
-                                    end
+          pane_attrs[:activePane] = freeze_pane[:active_pane] || if (freeze_pane[:col] || 0).positive? && (freeze_pane[:row] || 0).positive?
+                                                                   "bottomRight"
+                                                                 elsif (freeze_pane[:col] || 0).positive?
+                                                                   "topRight"
+                                                                 else
+                                                                   "bottomLeft"
+                                                                 end
           @builder.empty_tag("pane", pane_attrs)
         elsif split_pane
           pane_attrs = {}
           pane_attrs[:xSplit] = split_pane[:x_split].to_s if split_pane[:x_split]&.positive?
           pane_attrs[:ySplit] = split_pane[:y_split].to_s if split_pane[:y_split]&.positive?
           pane_attrs[:topLeftCell] = split_pane[:top_left_cell] if split_pane[:top_left_cell]
+          pane_attrs[:activePane] = split_pane[:active_pane] if split_pane[:active_pane]
+          pane_attrs[:state] = split_pane[:state].to_s if split_pane[:state]
           @builder.empty_tag("pane", pane_attrs)
         end
-        if selection
-          sel_attrs = {}
-          sel_attrs[:activeCell] = selection[:active_cell] if selection[:active_cell]
-          sel_attrs[:sqref] = selection[:sqref] || selection[:active_cell] if selection[:active_cell]
-          sel_attrs[:pane] = selection[:pane] if selection[:pane]
-          @builder.empty_tag("selection", sel_attrs)
+        active_selection = selection || (sheet_view[:selection] if sheet_view)
+        if active_selection
+          selections = active_selection.is_a?(Array) ? active_selection : [active_selection]
+          selections.each do |sel|
+            sel_attrs = {}
+            sel_attrs[:pane] = sel[:pane].to_s if sel[:pane]
+            sel_attrs[:activeCell] = sel[:active_cell].to_s if sel[:active_cell]
+            sel_attrs[:activeCellId] = sel[:active_cell_id].to_s if sel[:active_cell_id]
+            sqref = sel[:sqref] || sel[:active_cell]
+            sel_attrs[:sqref] = sqref.to_s if sqref
+            @builder.empty_tag("selection", sel_attrs) unless sel_attrs.empty?
+          end
         end
         @builder.close_tag("sheetView")
         @builder.close_tag("sheetViews")
@@ -1070,6 +1152,9 @@ module Xlsxrb
       end
 
       def write_data_validations(validations)
+        validations = validations.reject { |dv| dv[:sqref].nil? || dv[:sqref].to_s.empty? }
+        return if validations.empty?
+
         @builder.open_tag("dataValidations", { count: validations.size.to_s })
         validations.each do |dv|
           if dv[:in].is_a?(Array)
@@ -1089,6 +1174,8 @@ module Xlsxrb
           dv_attrs[:error] = dv[:error] if dv[:error]
           dv_attrs[:promptTitle] = dv[:prompt_title] if dv[:prompt_title]
           dv_attrs[:prompt] = dv[:prompt] if dv[:prompt]
+          dv_attrs[:showDropDown] = "1" if dv[:show_drop_down]
+          dv_attrs[:imeMode] = dv[:ime_mode].to_s if dv[:ime_mode]
 
           has_formulas = dv[:formula1] || dv[:formula2]
           if has_formulas
@@ -1145,7 +1232,7 @@ module Xlsxrb
         attrs[:scale] = opts[:scale].to_s if opts[:scale]
         attrs[:fitToWidth] = opts[:fit_to_width].to_s if opts[:fit_to_width]
         attrs[:fitToHeight] = opts[:fit_to_height].to_s if opts[:fit_to_height]
-        attrs[:firstPageNumber] = opts[:first_page_number].to_s if opts[:first_page_number]
+        attrs[:firstPageNumber] = opts[:first_page_number].to_s if opts[:first_page_number] && opts[:first_page_number].to_i >= 0
         attrs[:pageOrder] = opts[:page_order].to_s if opts[:page_order]
         attrs[:blackAndWhite] = "1" if opts[:black_and_white]
         attrs[:draft] = "1" if opts[:draft]
@@ -1164,7 +1251,14 @@ module Xlsxrb
       def write_row_breaks(breaks)
         @builder.open_tag("rowBreaks", { count: breaks.size.to_s, manualBreakCount: breaks.size.to_s })
         breaks.each do |brk|
-          @builder.empty_tag("brk", { id: brk.to_s, max: "16383", man: "1" })
+          attrs = if brk.is_a?(Hash)
+                    a = { id: (brk[:id] || brk[:row] || 0).to_s, max: (brk[:max] || 16_383).to_s, man: brk.fetch(:man, true) ? "1" : "0" }
+                    a[:min] = brk[:min].to_s if brk[:min]
+                    a
+                  else
+                    { id: brk.to_s, max: "16383", man: "1" }
+                  end
+          @builder.empty_tag("brk", attrs)
         end
         @builder.close_tag("rowBreaks")
       end
@@ -1172,7 +1266,14 @@ module Xlsxrb
       def write_col_breaks(breaks)
         @builder.open_tag("colBreaks", { count: breaks.size.to_s, manualBreakCount: breaks.size.to_s })
         breaks.each do |brk|
-          @builder.empty_tag("brk", { id: brk.to_s, max: "1048575", man: "1" })
+          attrs = if brk.is_a?(Hash)
+                    a = { id: (brk[:id] || brk[:col] || 0).to_s, max: (brk[:max] || 1_048_575).to_s, man: brk.fetch(:man, true) ? "1" : "0" }
+                    a[:min] = brk[:min].to_s if brk[:min]
+                    a
+                  else
+                    { id: brk.to_s, max: "1048575", man: "1" }
+                  end
+          @builder.empty_tag("brk", attrs)
         end
         @builder.close_tag("colBreaks")
       end
@@ -1268,16 +1369,32 @@ module Xlsxrb
       def write_columns(columns)
         @builder.open_tag("cols")
         columns.each do |col|
+          if col.is_a?(Elements::Column)
+            min = col.unmapped_data[:min] || (col.index + 1)
+            max = col.unmapped_data[:max] || (col.index + 1)
+            width = col.width
+            hidden = col.hidden
+            custom_width = col.custom_width || col.width
+            outline_level = col.outline_level
+            style_id = col.style_index
+          else
+            min = col[:min] || ((col[:index] || 0) + 1)
+            max = col[:max] || ((col[:index] || 0) + 1)
+            width = col[:width]
+            hidden = col[:hidden]
+            custom_width = col[:custom_width] || col[:width]
+            outline_level = col[:outline_level]
+            style_id = col[:style_index] || col[:style]
+          end
           attrs = {
-            min: ((col[:index] || col[:min] || 0) + 1).to_s,
-            max: ((col[:index] || col[:max] || col[:min] || 0) + 1).to_s
+            min: min.to_s,
+            max: max.to_s
           }
-          attrs[:width] = col[:width].to_s if col[:width]
-          attrs[:hidden] = "1" if col[:hidden]
-          attrs[:customWidth] = "1" if col[:custom_width] || col[:width]
-          attrs[:outlineLevel] = col[:outline_level].to_s if col[:outline_level]
-          style_id = col[:style_index] || col[:style]
-          attrs[:style] = style_id.to_s if style_id
+          attrs[:width] = width.to_s if width
+          attrs[:hidden] = "1" if hidden
+          attrs[:customWidth] = "1" if custom_width
+          attrs[:outlineLevel] = outline_level.to_s if outline_level
+          attrs[:style] = style_id.to_s if style_id.is_a?(Integer)
           @builder.empty_tag("col", attrs)
         end
         @builder.close_tag("cols")
@@ -1289,15 +1406,27 @@ module Xlsxrb
 
         value = cell[:value]
         formula = cell[:formula]
-        # For formula cells with cached values, don't infer type from value
-        type = formula ? cell[:type] : (cell[:type] || cell_type(value))
+        # For formula cells with cached values, infer type for booleans and strings
+        type = cell[:type] || if formula
+                                case value
+                                when true, false then "b"
+                                end
+                              else
+                                cell_type(value)
+                              end
         attrs[:t] = type if type
         col_idx = cell[:column_index]
         col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
-        style_id = cell[:style_index] || col_style
+        cell_style_id = cell[:style_index]
+        style_id = cell_style_id || col_style
         attrs[:s] = style_id.to_s if style_id.is_a?(Integer)
 
         if value.nil? && formula.nil?
+          if cell_style_id.is_a?(Integer)
+            attrs[:s] = cell_style_id.to_s
+          else
+            attrs.delete(:s)
+          end
           @builder.empty_tag("c", attrs)
           return
         end
@@ -1369,6 +1498,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