xlsxrb 0.1.13 → 0.1.15

data/lib/xlsxrb/ooxml/styles_parser.rb

@@ -3,18 +3,22 @@
 # rbs_inline: enabled
 
 require_relative "xml_parser"
+require_relative "../elements/styles"
 
 module Xlsxrb
   module Ooxml
     # SAX-based parser for xl/styles.xml.
-    # Returns a Hash with :num_fmts, :fonts, :fills, :borders, :cell_xfs, :cell_style_xfs.
+    # Returns an Elements::Styles (Hash) with :num_fmts, :fonts, :fills, :borders, :cell_xfs, :cell_style_xfs.
     class StylesParser
+      #: (String? xml_string) -> Elements::Styles
       def self.parse(xml_string)
-        return {} if xml_string.nil? || xml_string.empty?
+        return Elements::Styles.new if xml_string.nil? || xml_string.empty?
 
         listener = Listener.new
         XmlParser.parse(xml_string, listener)
-        listener.result
+        styles = Elements::Styles.new(listener.result)
+        styles.precompute!
+        styles
       end
 
       # SAX listener for parsing styles.xml content.
@@ -37,6 +41,7 @@ module Xlsxrb
           @current_fill = nil
           @current_fill_pattern = nil
           @current_border = nil
+          @current_border_side = nil
           @current_xf = nil
           @in_cell_xfs = false
           @in_cell_style_xfs = false
@@ -70,7 +75,11 @@ module Xlsxrb
           when "fgColor", "bgColor"
             handle_fill_color(localname, attrs) if @current_fill
           when "border"
-            @current_border = {} if parent_context?("borders")
+            if parent_context?("borders")
+              @current_border = {}
+              @current_border[:diagonal_up] = true if attrs["diagonalUp"] == "1"
+              @current_border[:diagonal_down] = true if attrs["diagonalDown"] == "1"
+            end
           when "left", "right", "top", "bottom", "diagonal"
             handle_border_side(localname, attrs)
           when "cellXfs"
@@ -81,6 +90,8 @@ module Xlsxrb
             handle_xf(attrs)
           when "alignment"
             handle_alignment(attrs)
+          when "protection"
+            handle_protection(attrs)
           end
         end
 
@@ -103,6 +114,8 @@ module Xlsxrb
               @result[:borders] << @current_border
               @current_border = nil
             end
+          when "left", "right", "top", "bottom", "diagonal"
+            @current_border_side = nil
           when "cellXfs"
             @in_cell_xfs = false
           when "cellStyleXfs"
@@ -124,10 +137,14 @@ module Xlsxrb
         end
 
         def handle_color(attrs)
-          return unless @current_font
-
-          color = extract_color(attrs)
-          @current_font[:color] = color unless color.empty?
+          if @current_font
+            color = extract_color(attrs)
+            @current_font[:color] = color unless color.empty?
+          elsif @current_border && @current_border_side
+            color = extract_color(attrs)
+            @current_border[@current_border_side] ||= {}
+            @current_border[@current_border_side][:color] = color unless color.empty?
+          end
         end
 
         def handle_fill_color(localname, attrs)
@@ -141,8 +158,10 @@ module Xlsxrb
         def handle_border_side(side, attrs)
           return unless @current_border
 
+          @current_border_side = side.to_sym
           style = attrs["style"]
-          @current_border[side.to_sym] = { style: style } if style
+          @current_border[@current_border_side] ||= {}
+          @current_border[@current_border_side][:style] = style if style
         end
 
         def handle_xf(attrs)
@@ -168,9 +187,20 @@ module Xlsxrb
           alignment[:vertical] = attrs["vertical"] if attrs["vertical"]
           alignment[:wrap_text] = true if attrs["wrapText"] == "1"
           alignment[:text_rotation] = attrs["textRotation"]&.to_i if attrs["textRotation"]
+          alignment[:indent] = attrs["indent"]&.to_i if attrs["indent"]
+          alignment[:shrink_to_fit] = true if attrs["shrinkToFit"] == "1"
           @current_xf[:alignment] = alignment unless alignment.empty?
         end
 
+        def handle_protection(attrs)
+          return unless @current_xf
+
+          protection = {}
+          protection[:locked] = attrs["locked"] == "1" unless attrs["locked"].nil?
+          protection[:hidden] = attrs["hidden"] == "1" unless attrs["hidden"].nil?
+          @current_xf[:protection] = protection unless protection.empty?
+        end
+
         def finalize_xf
           return unless @current_xf
 

data/lib/xlsxrb/ooxml/utils.rb

@@ -14,6 +14,10 @@ module Xlsxrb
       EPOCH_1900 = Date.new(1899, 12, 31) # serial 1 = Jan 1, 1900
       EPOCH_1900_JD = EPOCH_1900.jd
 
+      # Excel 1904 date system epoch.
+      EPOCH_1904 = Date.new(1904, 1, 1) # serial 0 = Jan 1, 1904
+      EPOCH_1904_JD = EPOCH_1904.jd
+
       # Built-in number format codes defined by SpreadsheetML.
       BUILTIN_NUM_FMT_CODES = {
         0 => "General",
@@ -56,35 +60,47 @@ module Xlsxrb
       DEFAULT_DATETIME_FORMAT = "yyyy\\-mm\\-dd\\ hh:mm:ss"
 
       class << self
-        # Converts a Date to an Excel serial number (1900 system).
-        def date_to_serial(date)
-          serial = date.jd - EPOCH_1900_JD
-          # Lotus 1-2-3 bug: serial 60 = Feb 29, 1900 (doesn't exist).
-          # Dates on or after Mar 1, 1900 (raw serial >= 60) need +1.
-          serial += 1 if serial >= 60
-          serial
+        # Converts a Date to an Excel serial number (1900 or 1904 system).
+        #: (Date date, ?date1904: bool) -> untyped
+        def date_to_serial(date, date1904: false)
+          if date1904
+            date.jd - EPOCH_1904_JD
+          else
+            serial = date.jd - EPOCH_1900_JD
+            # Lotus 1-2-3 bug: serial 60 = Feb 29, 1900 (doesn't exist).
+            # Dates on or after Mar 1, 1900 (raw serial >= 60) need +1.
+            serial += 1 if serial >= 60
+            serial
+          end
         end
 
-        # Converts an Excel serial number (1900 system) to a Date.
-        def serial_to_date(serial)
-          # Adjust for Lotus 1-2-3 bug.
-          serial -= 1 if serial > 60
-          EPOCH_1900 + serial
+        # Converts an Excel serial number (1900 or 1904 system) to a Date.
+        #: (Numeric serial, ?date1904: bool) -> Date
+        def serial_to_date(serial, date1904: false)
+          if date1904
+            EPOCH_1904 + serial
+          else
+            # Adjust for Lotus 1-2-3 bug.
+            serial -= 1 if serial > 60
+            EPOCH_1900 + serial
+          end
         end
 
-        # Converts a Time to a fractional Excel serial number (1900 system).
-        def datetime_to_serial(time)
+        # Converts a Time to a fractional Excel serial number (1900 or 1904 system).
+        #: (Time time, ?date1904: bool) -> Float
+        def datetime_to_serial(time, date1904: false)
           date = time.to_date
-          day_serial = date_to_serial(date)
+          day_serial = date_to_serial(date, date1904: date1904)
           # Fractional part: seconds since midnight / seconds per day
           seconds_since_midnight = (time.hour * 3600) + (time.min * 60) + time.sec
           day_serial + (seconds_since_midnight.to_f / 86_400)
         end
 
-        # Converts a fractional Excel serial number to a Time (1900 system, UTC).
-        def serial_to_datetime(serial)
+        # Converts a fractional Excel serial number to a Time (1900 or 1904 system, UTC).
+        #: (Numeric serial, ?date1904: bool) -> Time
+        def serial_to_datetime(serial, date1904: false)
           int_part, frac = serial.divmod(1)
-          date = serial_to_date(int_part)
+          date = serial_to_date(int_part, date1904: date1904)
           total_seconds = (frac * 86_400).round
           hours, remaining = total_seconds.divmod(3600)
           minutes, seconds = remaining.divmod(60)

data/lib/xlsxrb/ooxml/workbook_parser.rb

@@ -10,39 +10,77 @@ module Xlsxrb
     # Returns sheet list: [{ name:, sheet_id:, r_id: }, ...].
     class WorkbookParser
       def self.parse(xml_string)
-        return [] if xml_string.nil? || xml_string.empty?
+        parse_with_properties(xml_string)[:sheets]
+      end
+
+      def self.parse_with_properties(xml_string)
+        return { sheets: [], date1904: false, defined_names: [] } if xml_string.nil? || xml_string.empty?
 
         listener = Listener.new
         XmlParser.parse(xml_string, listener)
-        listener.sheets
+        { sheets: listener.sheets, date1904: listener.date1904, defined_names: listener.defined_names }
       end
 
-      # SAX listener for workbook.xml sheets.
+      # SAX listener for workbook.xml sheets, properties, and defined names.
       class Listener
         include REXML::SAX2Listener
 
-        attr_reader :sheets
+        attr_reader :sheets, :date1904, :defined_names
 
         def initialize
           @sheets = []
+          @date1904 = false
+          @defined_names = []
+          @in_defined_name = false
+          @current_dn = nil
+          @dn_text = +""
         end
 
         def start_element(_uri, localname, _qname, attrs)
-          return unless localname == "sheet"
-
-          name_attr = attrs["name"]
-          name_attr = REXML::Text.unnormalize(name_attr) if name_attr
+          case localname
+          when "sheet"
+            name_attr = attrs["name"]
+            name_attr = REXML::Text.unnormalize(name_attr) if name_attr
+            raw_state = attrs["state"]
+            state_sym = case raw_state
+                        when "hidden" then :hidden
+                        when "veryHidden" then :very_hidden
+                        else :visible
+                        end
+
+            @sheets << {
+              name: name_attr,
+              sheet_id: attrs["sheetId"]&.to_i,
+              r_id: attrs["r:id"] || attrs["id"] || attrs.find { |k, _| k.end_with?(":id") }&.last,
+              state: state_sym
+            }
+          when "workbookPr"
+            d1904 = attrs["date1904"]
+            @date1904 = %w[1 true].include?(d1904) unless d1904.nil?
+          when "definedName"
+            @in_defined_name = true
+            @current_dn = {
+              name: attrs["name"],
+              hidden: %w[1 true].include?(attrs["hidden"])
+            }
+            @current_dn[:local_sheet_id] = attrs["localSheetId"].to_i if attrs["localSheetId"]
+            @current_dn[:comment] = attrs["comment"] if attrs["comment"]
+            @dn_text = +""
+          end
+        end
 
-          @sheets << {
-            name: name_attr,
-            sheet_id: attrs["sheetId"]&.to_i,
-            r_id: attrs["r:id"] || attrs["id"] || attrs.find { |k, _| k.end_with?(":id") }&.last
-          }
+        def characters(text)
+          @dn_text << text if @in_defined_name
         end
 
-        def end_element(_uri, _localname, _qname); end
+        def end_element(_uri, localname, _qname)
+          return unless localname == "definedName" && @in_defined_name
 
-        def characters(_text); end
+          @current_dn[:value] = @dn_text.strip
+          @defined_names << @current_dn
+          @in_defined_name = false
+          @current_dn = nil
+        end
       end
     end
 
@@ -51,8 +89,28 @@ module Xlsxrb
       def self.parse(xml_string)
         return {} if xml_string.nil? || xml_string.empty?
 
+        sanitized = xml_string.lstrip
+        if sanitized.start_with?("<?xml")
+          first_decl_end = sanitized.index("?>")
+          if first_decl_end
+            decl = sanitized[0..(first_decl_end + 1)]
+            rest = sanitized[(first_decl_end + 2)..].gsub(/<\?xml\b[^>]*\?>/i, "")
+            sanitized = "#{decl}#{rest}".lstrip
+          end
+        end
+
         listener = Listener.new
-        XmlParser.parse(xml_string, listener)
+        begin
+          XmlParser.parse(sanitized, listener)
+        rescue StandardError
+          # Fallback to regex scanning if SAX parser fails on malformed XML
+          sanitized.scan(%r{<(?:[a-zA-Z0-9_]+:)?Relationship\b([^>]*)/?>}i) do |match|
+            attrs_str = match[0]
+            id = attrs_str[/\bId=["']([^"']+)["']/i, 1]
+            target = attrs_str[/\bTarget=["']([^"']+)["']/i, 1]
+            listener.relationships[id] = target if id && target
+          end
+        end
         listener.relationships
       end
 

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],
@@ -259,7 +262,7 @@ module Xlsxrb
             comment_idx += 1
             comment_writer = Xlsxrb::Ooxml::Writer.new
             sheet_comments.each do |c|
-              comment_writer.add_comment(c[:cell], c[:text], author: c[:author] || "Author")
+              comment_writer.add_comment(c[:cell] || c[:ref], c[:text], author: c[:author] || "Author")
             end
             zip.add_entry("xl/comments#{comment_idx}.xml", comment_writer.send(:generate_comments_xml, comment_writer.comments))
             zip.add_entry("xl/drawings/vmlDrawing#{comment_idx}.vml", comment_writer.send(:generate_vml_drawing_xml, comment_writer.comments))
@@ -495,11 +498,17 @@ module Xlsxrb
 
         b.open_tag("sheets")
         @sheets.each_with_index do |sheet, idx|
-          b.empty_tag("sheet", {
-                        name: sheet[:name],
-                        sheetId: (idx + 1).to_s,
-                        "r:id": "rId#{idx + 1}"
-                      })
+          s_name = sheet.respond_to?(:name) ? sheet.name : sheet[:name]
+          sheet_attrs = {
+            name: s_name,
+            sheetId: (idx + 1).to_s,
+            "r:id": "rId#{idx + 1}"
+          }
+          state = sheet.respond_to?(:state) ? sheet.state : sheet[:state]
+          if state && state.to_sym != :visible
+            sheet_attrs[:state] = state.to_sym == :very_hidden ? "veryHidden" : "hidden"
+          end
+          b.empty_tag("sheet", sheet_attrs)
         end
         b.close_tag("sheets")
 
@@ -508,9 +517,16 @@ module Xlsxrb
           b.open_tag("definedNames")
           @defined_names.each do |dn|
             dn_attrs = { name: dn[:name] }
-            dn_attrs[:localSheetId] = dn[:local_sheet_id].to_s if dn[:local_sheet_id]
+            local_id = dn[:local_sheet_id]
+            if !local_id && dn[:sheet]
+              target_name = dn[:sheet].to_s
+              matched_idx = @sheets.find_index { |s| (s.respond_to?(:name) ? s.name : s[:name]) == target_name }
+              local_id = matched_idx if matched_idx
+            end
+            dn_attrs[:localSheetId] = local_id.to_s if local_id
             dn_attrs[:hidden] = "1" if dn[:hidden]
-            b.tag("definedName", dn_attrs) { |_| b.text(dn[:value]) }
+            val = dn[:value] || (dn[:sheet] && dn[:range] ? "'#{dn[:sheet]}'!#{dn[:range]}" : dn[:range])
+            b.tag("definedName", dn_attrs) { |_| b.text(val) }
           end
           b.close_tag("definedNames")
         end
@@ -581,11 +597,26 @@ module Xlsxrb
         b.open_tag("styleSheet", { xmlns: SSML_NS })
 
         # Number formats
-        num_fmts = @styles&.dig(:num_fmts) || []
+        raw_num_fmts = @styles&.dig(:num_fmts) || []
+        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)
+                     raw_num_fmts.map do |nf|
+                       if nf.is_a?(Hash)
+                         id = (nf[:num_fmt_id] || nf[:id]).to_i
+                         code = (nf[:format_code] || nf[:code] || nf[:format]).to_s
+                         { num_fmt_id: id, format_code: code }
+                       elsif nf.is_a?(Array) && nf.size == 2
+                         { num_fmt_id: nf[0].to_i, format_code: nf[1].to_s }
+                       end
+                     end.compact
+                   else
+                     []
+                   end
         unless num_fmts.empty?
           b.tag("numFmts", { count: num_fmts.size.to_s }) do |_|
             num_fmts.each do |nf|
-              b.empty_tag("numFmt", { numFmtId: nf[:num_fmt_id].to_s, formatCode: nf[:format_code] }) if nf.is_a?(Hash)
+              b.empty_tag("numFmt", { numFmtId: nf[:num_fmt_id].to_s, formatCode: nf[:format_code] })
             end
           end
         end
@@ -596,13 +627,13 @@ module Xlsxrb
         b.tag("fonts", { count: fonts.size.to_s }) do |_|
           fonts.each do |font_props|
             b.tag("font") do |_|
-              b.empty_tag("sz", { val: (font_props[:sz] || 11).to_s }) if font_props[:sz] || fonts == [{}]
               b.empty_tag("b") if font_props[:bold]
               b.empty_tag("i") if font_props[:italic]
               b.empty_tag("strike") if font_props[:strike]
               if font_props[:underline]
                 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]
               b.empty_tag("name", { val: font_props[:name] || "Calibri" })
             end
@@ -646,7 +677,16 @@ module Xlsxrb
                 side_data = border_props[side]
                 if side_data
                   b.tag(side.to_s, { style: side_data[:style] }) do |_|
-                    b.empty_tag("color", { rgb: side_data[:color] }) if side_data[:color]
+                    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
                   end
                 else
                   b.empty_tag(side.to_s)
@@ -662,7 +702,7 @@ module Xlsxrb
         end
 
         # Cell XFs (formatting)
-        xf_entries = @styles&.dig(:xf_entries) || []
+        xf_entries = @styles&.dig(:cell_xfs) || @styles&.dig(:xf_entries) || []
         xf_count = [xf_entries.size, 1].max
         b.tag("cellXfs", { count: xf_count.to_s }) do |_|
           xf_entries.each do |xf|
@@ -880,23 +920,25 @@ 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)
-        ws = WorksheetWriter.new(io)
+        date1904 = @workbook_properties&.[](:date1904) ? true : false
+        ws = WorksheetWriter.new(io, date1904: date1904)
         ws.start(
           columns: sheet[:columns] || [],
           sheet_properties: sheet_properties,
           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|
@@ -914,6 +956,8 @@ module Xlsxrb
               attrs[:hidden] = true if row.hidden
               attrs[:custom_height] = true if row.custom_height
               attrs[:outline_level] = row.outline_level if row.outline_level
+              style_idx = row.unmapped_data&.[](:style_index) || (row.respond_to?(:style_index) && row.style_index)
+              attrs[:style_index] = style_idx if style_idx
               ws.write_row(row.index, row.cells, attrs: attrs, unmapped: row.unmapped_data || [], sst_index: @shared_strings_index)
             end
           end
@@ -921,6 +965,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,
@@ -934,6 +979,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,
@@ -1020,7 +1066,18 @@ module Xlsxrb
         b.tag("cp:keywords") { |_| b.text(@core_properties[:keywords]) } if @core_properties[:keywords]
         b.tag("dc:description") { |_| b.text(@core_properties[:description]) } if @core_properties[:description]
         b.tag("cp:lastModifiedBy") { |_| b.text(@core_properties[:last_modified_by]) } if @core_properties[:last_modified_by]
+        b.tag("cp:revision") { |_| b.text(@core_properties[:revision]) } if @core_properties[:revision]
+        if @core_properties[:created]
+          created_val = @core_properties[:created].respond_to?(:iso8601) ? @core_properties[:created].iso8601 : @core_properties[:created]
+          b.tag("dcterms:created", { "xsi:type": "dcterms:W3CDTF" }) { |_| b.text(created_val) }
+        end
+        if @core_properties[:modified]
+          modified_val = @core_properties[:modified].respond_to?(:iso8601) ? @core_properties[:modified].iso8601 : @core_properties[:modified]
+          b.tag("dcterms:modified", { "xsi:type": "dcterms:W3CDTF" }) { |_| b.text(modified_val) }
+        end
         b.tag("cp:category") { |_| b.text(@core_properties[:category]) } if @core_properties[:category]
+        b.tag("cp:contentStatus") { |_| b.text(@core_properties[:content_status]) } if @core_properties[:content_status]
+        b.tag("dc:language") { |_| b.text(@core_properties[:language]) } if @core_properties[:language]
         b.close_tag("cp:coreProperties")
         io.string
       end
@@ -1051,11 +1108,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) }