xlsxrb 0.1.13 → 0.1.15

data/lib/xlsxrb/ooxml/worksheet_writer.rb

@@ -26,14 +26,20 @@ module Xlsxrb
 
       INTEGER_STRINGS = (0..65_535).map(&:to_s).freeze
 
-      def initialize(io)
+      def initialize(io, date1904: false)
         @io = io
+        @date1904 = date1904 ? true : false
         @builder = XmlBuilder.new(@io)
         @row_buffer = String.new(capacity: 65_536)
         @started = false
         @finished = false
       end
 
+      def set_column_style(col_index, style_id)
+        @column_styles ||= {}
+        @column_styles[col_index] = style_id
+      end
+
       # Write the worksheet header. Call once before writing rows.
       # Options for pre-sheetData elements:
       #   sheet_properties: Hash of sheet-level properties (:tab_color, etc.)
@@ -41,15 +47,35 @@ module Xlsxrb
       #   split_pane: { x_split:, y_split:, top_left_cell: }
       #   selection: { active_cell:, sqref:, pane: }
       #   sheet_view: Hash of sheet view properties
-      def start(columns: [], sheet_properties: nil, freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil)
+      def start(columns: [], sheet_properties: nil, freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil, sheet_format: nil)
         return if @started
 
         @started = true
         @builder.declaration
         @builder.open_tag("worksheet", { xmlns: SSML_NS, "xmlns:r": DOC_REL_NS })
 
+        @column_styles ||= {}
+        if columns && !columns.empty?
+          columns.each do |col|
+            if col.is_a?(Elements::Column)
+              s = col.style_index
+              min = col.index
+              max = col.index
+            else
+              s = col[:style_index] || col[:style]
+              min = col[:index] || col[:min] || 0
+              max = col[:index] || col[:max] || col[:min] || 0
+            end
+            next unless s
+
+            (min..max).each { |i| @column_styles[i] = s }
+          end
+        end
+        @column_styles = nil if @column_styles.empty?
+
         write_sheet_properties(sheet_properties) if sheet_properties && !sheet_properties.empty?
         write_sheet_views(freeze_pane: freeze_pane, split_pane: split_pane, selection: selection, sheet_view: sheet_view) if freeze_pane || split_pane || selection || (sheet_view && !sheet_view.empty?)
+        write_sheet_format_pr(sheet_format) if sheet_format && !sheet_format.empty?
         write_columns(columns) unless columns.empty?
 
         @builder.open_tag("sheetData")
@@ -63,12 +89,14 @@ module Xlsxrb
         row_num_str = row_num.to_s
         buf = @row_buffer ||= String.new(capacity: 65_536)
         buf << '<row r="' << row_num_str << '"'
+        buf << ' s="' << attrs[:style_index].to_s << '" customFormat="1"' if attrs[:style_index].is_a?(Integer)
         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]
         buf << ">"
 
@@ -77,25 +105,32 @@ module Xlsxrb
             value = cell.value
             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
             formula_ca = false
             cell_type_val = nil
           elsif cell.is_a?(Hash)
             value = cell[:value]
             style_id = cell[:style_index]
-            col_ref = cell[:ref] || "#{column_letter(cell[:column_index])}#{row_num_str}"
+            col_idx = cell[:column_index]
+            col_ref = cell[:ref] || (col_idx ? "#{column_letter(col_idx)}#{row_num_str}" : nil)
             formula = cell[:formula]
             formula_ca = cell[:formula_ca]
             cell_type_val = cell[:type]
           else
             value = cell
             style_id = nil
+            col_idx = nil
             col_ref = nil
             formula = nil
             formula_ca = false
             cell_type_val = nil
           end
 
+          col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
+          style_id ||= attrs[:style_index] || col_style
+          style_id = nil unless style_id.is_a?(Integer)
+
           # Fast path for common unstyled cells
           if !formula && !style_id && !cell_type_val
             case value
@@ -117,7 +152,7 @@ module Xlsxrb
               buf << '<c r="' << col_ref << '"/>'
               next
             when Date
-              serial = Xlsxrb::Ooxml::Utils.date_to_serial(value)
+              serial = Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: @date1904)
               buf << '<c r="' << col_ref << '"><v>' << serial.to_s << "</v></c>"
               next
             end
@@ -137,13 +172,25 @@ module Xlsxrb
 
           xml_val = value
           type = cell_type_val
-          formula_expr = nil
+          formula_type = nil
+          formula_ref = nil
+          formula_si = nil
 
           if formula
             if formula.is_a?(Xlsxrb::Elements::Formula)
               formula_expr = formula.expression
               formula_ca = formula.calculate_always
-              xml_val = formula.cached_value || value || nil
+              formula_type = formula.type
+              formula_ref = formula.ref
+              formula_si = formula.shared_index
+              xml_val = formula.cached_value.nil? ? (value || nil) : 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
             else
               formula_expr = formula
               xml_val = value || nil
@@ -175,9 +222,9 @@ module Xlsxrb
               xml_val = "0"
               type = "b"
             when Date
-              xml_val = Xlsxrb::Ooxml::Utils.date_to_serial(value)
+              xml_val = Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: @date1904)
             when Time
-              xml_val = Xlsxrb::Ooxml::Utils.datetime_to_serial(value)
+              xml_val = Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: @date1904)
             when BigDecimal
               xml_val = value.to_s("F")
             when Xlsxrb::Elements::CellError
@@ -229,16 +276,24 @@ module Xlsxrb
               buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
             end
           elsif formula_expr
-            buf << if formula_ca
-                     '><f ca="1">'
-                   else
-                     "><f>"
-                   end
-            buf << escape_xml(formula_expr) << "</f>"
+            f_attrs = +""
+            if formula_type
+              case formula_type.to_sym
+              when :array
+                f_attrs << ' t="array"'
+                f_attrs << %( ref="#{formula_ref}") if formula_ref
+              when :shared
+                f_attrs << ' t="shared"'
+                f_attrs << %( si="#{formula_si}") if formula_si
+                f_attrs << %( ref="#{formula_ref}") if formula_ref
+              end
+            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
-              buf << "</c>"
+              buf << "<v>0</v></c>"
             end
           else
             buf << "><v>" << xml_val.to_s << "</v></c>"
@@ -262,7 +317,7 @@ module Xlsxrb
         row_num_str = row_num < 65_536 ? INTEGER_STRINGS[row_num] : row_num.to_s
         buf = @row_buffer ||= String.new(capacity: 65_536)
 
-        if styles.nil? && attrs.nil?
+        if styles.nil? && attrs.nil? && @column_styles.nil?
           buf << "<row r=\"#{row_num_str}\">"
           col_index = 0
           max_len = values.length
@@ -292,7 +347,7 @@ module Xlsxrb
                 next
               end
               formula_expr = value[1..]
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f></c>"
+              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>"
             when false
@@ -300,35 +355,54 @@ module Xlsxrb
             when Date
               date_style_id = style_map ? style_map["__xlsxrb_date"] : nil
               buf << if date_style_id
-                       "<c r=\"#{col_ref}#{row_num_str}\" s=\"#{date_style_id}\"><v>#{Xlsxrb::Ooxml::Utils.date_to_serial(value)}</v></c>"
+                       "<c r=\"#{col_ref}#{row_num_str}\" s=\"#{date_style_id}\"><v>#{Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: @date1904)}</v></c>"
                      else
-                       "<c r=\"#{col_ref}#{row_num_str}\"><v>#{Xlsxrb::Ooxml::Utils.date_to_serial(value)}</v></c>"
+                       "<c r=\"#{col_ref}#{row_num_str}\"><v>#{Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: @date1904)}</v></c>"
                      end
             when Time
               time_style_id = style_map ? style_map["__xlsxrb_time"] : nil
               buf << if time_style_id
-                       "<c r=\"#{col_ref}#{row_num_str}\" s=\"#{time_style_id}\"><v>#{Xlsxrb::Ooxml::Utils.datetime_to_serial(value)}</v></c>"
+                       "<c r=\"#{col_ref}#{row_num_str}\" s=\"#{time_style_id}\"><v>#{Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: @date1904)}</v></c>"
                      else
-                       "<c r=\"#{col_ref}#{row_num_str}\"><v>#{Xlsxrb::Ooxml::Utils.datetime_to_serial(value)}</v></c>"
+                       "<c r=\"#{col_ref}#{row_num_str}\"><v>#{Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: @date1904)}</v></c>"
                      end
             when Xlsxrb::Elements::Formula
               formula_expr = value.expression
               formula_expr = formula_expr[1..] if formula_expr.start_with?("=")
-              buf << if value.cached_value
-                       "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f><v>#{value.cached_value}</v></c>"
-                     else
-                       "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f></c>"
-                     end
+              f_attrs = +""
+              if value.type
+                case value.type.to_sym
+                when :array
+                  f_attrs << ' t="array"'
+                  f_attrs << %( ref="#{value.ref}") if value.ref
+                when :shared
+                  f_attrs << ' t="shared"'
+                  f_attrs << %( si="#{value.shared_index}") if value.shared_index
+                  f_attrs << %( ref="#{value.ref}") if value.ref
+                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>"
             when Hash
               if value.key?(:formula)
-                formula_expr = value[:formula]
+                formula_expr = value[:formula] || value[:expression]
                 formula_expr = formula_expr[1..] if formula_expr.start_with?("=")
-                xml_val = value[:value]
-                buf << if xml_val
-                         "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f><v>#{xml_val}</v></c>"
-                       else
-                         "<c r=\"#{col_ref}#{row_num_str}\"><f>#{escape_xml(formula_expr)}</f></c>"
-                       end
+                f_attrs = +""
+                if value[:type]
+                  case value[:type].to_sym
+                  when :array
+                    f_attrs << ' t="array"'
+                    f_attrs << %( ref="#{value[:ref]}") if value[:ref]
+                  when :shared
+                    f_attrs << ' t="shared"'
+                    f_attrs << %( si="#{value[:si] || value[:shared_index]}") if value[:si] || value[:shared_index]
+                    f_attrs << %( ref="#{value[:ref]}") if value[:ref]
+                  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>"
               end
             when Xlsxrb::Elements::CellError
               buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"e\"><v>#{value.code}</v></c>"
@@ -353,13 +427,13 @@ module Xlsxrb
         end
 
         is_styles_collection = styles && (styles.is_a?(Array) || styles.is_a?(Hash))
-        single_style_id = nil
-        single_style_id = style_map[styles] if styles && style_map && !is_styles_collection
+        single_style_id = resolve_style_id(styles, style_map) unless is_styles_collection
 
         buf << '<row r="' << row_num_str << '"'
         if attrs
           buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"' if attrs[:height]
           buf << ' hidden="1"' if attrs[:hidden]
+          buf << ' collapsed="1"' if attrs[:collapsed]
           buf << ' outlineLevel="' << attrs[:outline_level].to_s << '"' if attrs[:outline_level]
         end
         buf << ">"
@@ -370,17 +444,26 @@ 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
-          if is_styles_collection && style_map
+          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 = style_map[style_name] if style_name
+            style_id = resolve_style_id(style_name, style_map)
+          end
+
+          if 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
           end
 
           col_ref = COLUMN_LETTERS[col_index] || column_letter(col_index)
@@ -425,11 +508,11 @@ module Xlsxrb
               col_index += 1
               next
             when Date
-              buf << '<c r="' << col_ref << row_num_str << '"><v>' << Xlsxrb::Ooxml::Utils.date_to_serial(value).to_s << "</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '"><v>' << Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: @date1904).to_s << "</v></c>"
               col_index += 1
               next
             when Time
-              buf << '<c r="' << col_ref << row_num_str << '"><v>' << Xlsxrb::Ooxml::Utils.datetime_to_serial(value).to_s << "</v></c>"
+              buf << '<c r="' << col_ref << row_num_str << '"><v>' << Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: @date1904).to_s << "</v></c>"
               col_index += 1
               next
             end
@@ -438,6 +521,9 @@ module Xlsxrb
           # General path: styled, formula, rich text, or complex cell
           formula_expr = nil
           formula_ca = false
+          formula_type = nil
+          formula_ref = nil
+          formula_si = nil
           xml_val = value
           type = nil
 
@@ -445,6 +531,9 @@ module Xlsxrb
           when Xlsxrb::Elements::Formula
             formula_expr = value.expression
             formula_ca = value.calculate_always
+            formula_type = value.type
+            formula_ref = value.ref
+            formula_si = value.shared_index
             xml_val = value.cached_value
             case value.cached_value
             when String
@@ -458,9 +547,12 @@ module Xlsxrb
             end
           when Hash
             if value.key?(:formula)
-              formula_expr = value[:formula]
+              formula_expr = value[:formula] || value[:expression]
               formula_ca = value[:calculate_always] || false
-              xml_val = value[:value]
+              formula_type = value[:type]
+              formula_ref = value[:ref]
+              formula_si = value[:si] || value[:shared_index]
+              xml_val = value[:value] || value[:cached_value]
               case xml_val
               when String
                 type = "str"
@@ -476,7 +568,7 @@ module Xlsxrb
             if value.start_with?("=") && value.length > 1
               formula_expr = value
               xml_val = nil
-            else
+            elsif sst_index
               idx = sst_index[value]
               unless idx
                 sst << value
@@ -485,16 +577,24 @@ module Xlsxrb
               end
               xml_val = idx
               type = "s"
+            else
+              xml_val = value
+              type = "inlineStr"
             end
           when Xlsxrb::Elements::RichText
-            idx = sst_index[value]
-            unless idx
-              sst << value
-              idx = sst.size - 1
-              sst_index[value] = idx
+            if 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
-            xml_val = idx
-            type = "s"
           when true
             xml_val = "1"
             type = "b"
@@ -502,9 +602,9 @@ module Xlsxrb
             xml_val = "0"
             type = "b"
           when Date
-            xml_val = Xlsxrb::Ooxml::Utils.date_to_serial(value)
+            xml_val = Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: @date1904)
           when Time
-            xml_val = Xlsxrb::Ooxml::Utils.datetime_to_serial(value)
+            xml_val = Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: @date1904)
           when BigDecimal
             xml_val = value.to_s("F")
           when Xlsxrb::Elements::CellError
@@ -518,17 +618,27 @@ module Xlsxrb
           buf << ' s="' << style_id.to_s << '"' if style_id
           buf << ' t="' << type << '"' if type
           if formula_expr
-            buf << if formula_ca
-                     '><f ca="1">'
-                   else
-                     "><f>"
-                   end
-            buf << escape_xml(formula_expr) << "</f>"
+            f_attrs = +""
+            if formula_type
+              case formula_type.to_sym
+              when :array
+                f_attrs << ' t="array"'
+                f_attrs << %( ref="#{formula_ref}") if formula_ref
+              when :shared
+                f_attrs << ' t="shared"'
+                f_attrs << %( si="#{formula_si}") if formula_si
+                f_attrs << %( ref="#{formula_ref}") if formula_ref
+              end
+            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
-              buf << "</c>"
+              buf << "<v>0</v></c>"
             end
+          elsif type == "inlineStr"
+            buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
           else
             buf << "><v>" << xml_val.to_s << "</v></c>"
           end
@@ -545,12 +655,12 @@ module Xlsxrb
 
       # Write the worksheet footer. Call once after all rows.
       # Options for post-sheetData elements (in OOXML order):
-      def finish(drawing_rid: nil, sheet_protection: nil, auto_filter: nil,
+      def finish(drawing_rid: nil, sheet_protection: 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, tables: nil, table_start_rid: nil,
+                 col_breaks: nil, cell_watches: nil, tables: nil, table_start_rid: nil,
                  legacy_drawing_rid: nil, sparkline_groups: nil)
         return if @finished
 
@@ -564,6 +674,7 @@ module Xlsxrb
 
         # Elements must appear in OOXML specification order after sheetData
         write_sheet_protection(sheet_protection) if sheet_protection
+        write_protected_ranges(protected_ranges) if protected_ranges && !protected_ranges.empty?
         write_auto_filter(auto_filter, filter_columns, sort_state) if auto_filter
         write_merge_cells(merge_cells) if merge_cells && !merge_cells.empty?
         write_conditional_formatting(conditional_formats) if conditional_formats && !conditional_formats.empty?
@@ -575,6 +686,7 @@ module Xlsxrb
         write_header_footer(header_footer) if header_footer && !header_footer.empty?
         write_row_breaks(row_breaks) if row_breaks && !row_breaks.empty?
         write_col_breaks(col_breaks) if col_breaks && !col_breaks.empty?
+        write_cell_watches(cell_watches) if cell_watches && !cell_watches.empty?
         @builder.empty_tag("drawing", { "r:id": drawing_rid }) if drawing_rid
         @builder.empty_tag("legacyDrawing", { "r:id": legacy_drawing_rid }) if legacy_drawing_rid
         write_table_parts(tables, table_start_rid) if tables && !tables.empty?
@@ -584,6 +696,17 @@ module Xlsxrb
 
       private
 
+      def resolve_style_id(style, style_map)
+        return nil if style.nil?
+
+        if style_map
+          mapped = style_map[style] || style_map[style.to_s]
+          return mapped if mapped
+        end
+
+        style.is_a?(Integer) ? style : nil
+      end
+
       # --- Pre-sheetData elements ---
 
       def write_sheet_properties(props)
@@ -653,6 +776,22 @@ module Xlsxrb
         @builder.close_tag("sheetViews")
       end
 
+      def write_sheet_format_pr(fmt)
+        return if fmt.nil? || fmt.empty?
+
+        attrs = {}
+        attrs[:defaultRowHeight] = fmt[:default_row_height].to_s if fmt[:default_row_height]
+        attrs[:defaultColWidth] = fmt[:default_col_width].to_s if fmt[:default_col_width]
+        attrs[:baseColWidth] = fmt[:base_col_width].to_s if fmt[:base_col_width]
+        attrs[:outlineLevelRow] = fmt[:outline_level_row].to_s if fmt[:outline_level_row]
+        attrs[:outlineLevelCol] = fmt[:outline_level_col].to_s if fmt[:outline_level_col]
+        attrs[:customHeight] = "1" if fmt[:custom_height]
+        attrs[:zeroHeight] = "1" if fmt[:zero_height]
+        attrs[:thickTop] = "1" if fmt[:thick_top]
+        attrs[:thickBottom] = "1" if fmt[:thick_bottom]
+        @builder.empty_tag("sheetFormatPr", attrs) unless attrs.empty?
+      end
+
       # --- Post-sheetData elements (in OOXML order) ---
 
       def write_sheet_protection(opts)
@@ -681,6 +820,28 @@ module Xlsxrb
         @builder.empty_tag("sheetProtection", attrs)
       end
 
+      def write_protected_ranges(ranges)
+        @builder.open_tag("protectedRanges")
+        ranges.each do |pr|
+          attrs = { sqref: pr[:sqref].to_s, name: pr[:name].to_s }
+          attrs[:password] = pr[:password].to_s if pr[:password]
+          attrs[:algorithmName] = pr[:algorithm_name].to_s if pr[:algorithm_name]
+          attrs[:hashValue] = pr[:hash_value].to_s if pr[:hash_value]
+          attrs[:saltValue] = pr[:salt_value].to_s if pr[:salt_value]
+          attrs[:spinCount] = pr[:spin_count].to_s if pr[:spin_count]
+          attrs[:securityDescriptor] = pr[:security_descriptor].to_s if pr[:security_descriptor]
+          sds = pr[:security_descriptors] || []
+          if sds.empty?
+            @builder.empty_tag("protectedRange", attrs)
+          else
+            @builder.open_tag("protectedRange", attrs)
+            sds.each { |sd| @builder.tag("securityDescriptor") { @builder.text(sd.to_s) } }
+            @builder.close_tag("protectedRange")
+          end
+        end
+        @builder.close_tag("protectedRanges")
+      end
+
       def write_auto_filter(range, filter_columns, sort_state)
         if (filter_columns && !filter_columns.empty?) || sort_state
           @builder.open_tag("autoFilter", { ref: range })
@@ -945,7 +1106,8 @@ module Xlsxrb
       def write_hyperlinks(links)
         @builder.open_tag("hyperlinks")
         links.each_with_index do |link, idx|
-          h_attrs = { ref: link[:cell] }
+          cell_ref = link[:cell] || link[:ref]
+          h_attrs = { ref: cell_ref }
           h_attrs[:"r:id"] = "rId#{link[:_rid] || (idx + 1)}" if link[:url]
           h_attrs[:location] = link[:location] if link[:location]
           h_attrs[:display] = link[:display] if link[:display]
@@ -1015,6 +1177,14 @@ module Xlsxrb
         @builder.close_tag("colBreaks")
       end
 
+      def write_cell_watches(watches)
+        @builder.open_tag("cellWatches")
+        watches.each do |w|
+          @builder.empty_tag("cellWatch", { r: w.to_s })
+        end
+        @builder.close_tag("cellWatches")
+      end
+
       def write_table_parts(tables, start_rid)
         @builder.open_tag("tableParts", { count: tables.size.to_s })
         tables.each_with_index do |_tbl, idx|
@@ -1106,6 +1276,8 @@ module Xlsxrb
           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
           @builder.empty_tag("col", attrs)
         end
         @builder.close_tag("cols")
@@ -1120,7 +1292,10 @@ module Xlsxrb
         # For formula cells with cached values, don't infer type from value
         type = formula ? cell[:type] : (cell[:type] || cell_type(value))
         attrs[:t] = type if type
-        attrs[:s] = cell[:style_index].to_s if cell[:style_index]
+        col_idx = cell[:column_index]
+        col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
+        style_id = cell[:style_index] || col_style
+        attrs[:s] = style_id.to_s if style_id.is_a?(Integer)
 
         if value.nil? && formula.nil?
           @builder.empty_tag("c", attrs)
@@ -1130,14 +1305,36 @@ module Xlsxrb
         @builder.open_tag("c", attrs)
         if formula
           f_attrs = {}
-          f_attrs[:ca] = "1" if cell[:formula_ca]
+          formula_text = formula
+          if formula.is_a?(Xlsxrb::Elements::Formula)
+            formula_text = formula.expression
+            formula_text = formula_text[1..] if formula_text.start_with?("=")
+            f_attrs[:t] = formula.type.to_s if formula.type
+            f_attrs[:ref] = formula.ref if formula.ref
+            f_attrs[:si] = formula.shared_index.to_s if formula.shared_index
+            f_attrs[:ca] = "1" if formula.calculate_always
+          else
+            formula_text = formula_text[1..] if formula_text.is_a?(String) && formula_text.start_with?("=")
+            f_type = cell[:formula_type] || cell[:type]
+            if f_type && %i[array shared].include?(f_type.to_sym)
+              f_attrs[:t] = f_type.to_s
+              f_attrs[:ref] = cell[:formula_ref] || cell[:ref] if cell[:formula_ref] || (f_type.to_s == "array" && cell[:ref])
+              f_attrs[:si] = cell[:formula_si].to_s if cell[:formula_si]
+            end
+            f_attrs[:ca] = "1" if cell[:formula_ca]
+          end
           if f_attrs.empty?
-            @builder.tag("f") { |b| b.text(formula) }
+            @builder.tag("f") { |b| b.text(formula_text) }
           else
-            @builder.tag("f", f_attrs) { |b| b.text(formula) }
+            @builder.tag("f", f_attrs) { |b| b.text(formula_text) }
           end
         end
-        @builder.tag("v") { |b| b.text(xml_cell_value(value, type)) } unless value.nil?
+        v_val = if value.nil?
+                  formula ? "0" : nil
+                else
+                  xml_cell_value(value, type)
+                end
+        @builder.tag("v") { |b| b.text(v_val) } unless v_val.nil?
         @builder.close_tag("c")
       end
 

data/lib/xlsxrb/ooxml/writer/features_xml.rb

@@ -393,11 +393,13 @@ module Xlsxrb
           when true, false
             %(<c r="#{cell_ref}" t="b"#{s_attr}#{ph_attr}><v>#{value ? 1 : 0}</v></c>)
           when Time
-            serial = Xlsxrb::Ooxml::Utils.datetime_to_serial(value)
+            date1904 = @workbook_properties&.[](:date1904) ? true : false
+            serial = Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: date1904)
             dt_attr = s_attr.empty? && (dt_style = resolve_style_index(datetime_num_fmt_id)) ? %( s="#{dt_style}") : s_attr
             %(<c r="#{cell_ref}"#{dt_attr}#{ph_attr}><v>#{serial}</v></c>)
           when Date
-            serial = Xlsxrb::Ooxml::Utils.date_to_serial(value)
+            date1904 = @workbook_properties&.[](:date1904) ? true : false
+            serial = Xlsxrb::Ooxml::Utils.date_to_serial(value, date1904: date1904)
             ds_attr = s_attr.empty? && (date_style = resolve_style_index(date_num_fmt_id)) ? %( s="#{date_style}") : s_attr
             %(<c r="#{cell_ref}"#{ds_attr}#{ph_attr}><v>#{serial}</v></c>)
           when Numeric
@@ -713,7 +715,7 @@ module Xlsxrb
                        "<vt:i4>#{prop[:value]}</vt:i4>"
                      when :float, :r8
                        "<vt:r8>#{prop[:value]}</vt:r8>"
-                     when :bool
+                     when :bool, :boolean
                        "<vt:bool>#{prop[:value] ? "true" : "false"}</vt:bool>"
                      when :date, :filetime
                        "<vt:filetime>#{prop[:value]}</vt:filetime>"