xlsxrb 0.1.15 → 0.1.17

data/lib/xlsxrb/ooxml/shared_strings_parser.rb

@@ -10,6 +10,9 @@ module Xlsxrb
     # SAX-based parser for xl/sharedStrings.xml.
     # Returns an Array of strings (index = SST index).
     class SharedStringsParser
+      TAG_DELIM_BYTES = [62, 32, 47, 9, 10, 13].freeze # '>', ' ', '/', '\t', '\n', '\r'
+      private_constant :TAG_DELIM_BYTES
+
       # Parses all shared strings and returns an Array of strings.
       def self.parse(xml_string, _part_name: "xl/sharedStrings.xml")
         return [] if xml_string.nil? || xml_string.empty?
@@ -44,22 +47,43 @@ module Xlsxrb
 
       def self.fast_scan(xml_src)
         xml = xml_src.b
-        sst_start = xml.index("<sst")
+        sst_term = xml.index("sst")
+        return unless sst_term
+
+        sst_start = xml.rindex("<", sst_term)
         return unless sst_start
 
+        prefix = xml.byteslice(sst_start + 1, sst_term - (sst_start + 1))
+        return if !prefix.empty? && !prefix.end_with?(":")
+
         sst_open_end = xml.index(">", sst_start)
         return unless sst_open_end
         return if xml.getbyte(sst_open_end - 1) == 47 # self-closing <sst/>
 
-        sst_end = xml.index("</sst>", sst_open_end)
+        sst_end = xml.index("</#{prefix}sst>", sst_open_end)
         sst_end ||= xml.bytesize
 
+        si_start_pattern = "<#{prefix}si"
+        si_start_len = si_start_pattern.bytesize
+        si_end_tag = "</#{prefix}si>"
+        si_end_len = si_end_tag.bytesize
+
+        t_start_pattern = "<#{prefix}t"
+        t_start_len = t_start_pattern.bytesize
+        t_end_tag = "</#{prefix}t>"
+        t_end_len = t_end_tag.bytesize
+
+        rph_start_pattern = "<#{prefix}rPh"
+        rph_end_tag = "</#{prefix}rPh>"
+        rph_end_len = rph_end_tag.bytesize
+        has_rph = xml.include?(rph_start_pattern)
+
         pos = sst_open_end + 1
         while pos < sst_end
-          si_start = xml.index("<si", pos)
+          si_start = xml.index(si_start_pattern, pos)
           break unless si_start && si_start < sst_end
 
-          si_open_end = xml.index(">", si_start + 3)
+          si_open_end = xml.index(">", si_start + si_start_len)
           break unless si_open_end
 
           # Self-closing <si/>
@@ -69,53 +93,84 @@ module Xlsxrb
             next
           end
 
-          si_end = xml.index("</si>", si_open_end + 1)
+          si_end = xml.index(si_end_tag, si_open_end + 1)
           break unless si_end
 
           # Fast path: check for simple single <t>...</t> inside <si>
-          first_t = xml.index("<t", si_open_end + 1)
+          first_t = xml.index(t_start_pattern, si_open_end + 1)
           if first_t && first_t < si_end
-            t_open_end = xml.index(">", first_t + 2)
-            if t_open_end && t_open_end < si_end
-              if xml.getbyte(t_open_end - 1) == 47 # <t/>
-                str = ""
-              else
-                t_end = xml.index("</t>", t_open_end + 1)
-                if t_end && t_end <= si_end
-                  next_t = xml.index("<t", t_end + 4)
-                  if next_t && next_t < si_end
-                    # Multiple <t> tags (rich text runs)
-                    str = extract_multi_t(xml, si_open_end + 1, si_end)
+            tb = xml.getbyte(first_t + t_start_len)
+            if TAG_DELIM_BYTES.include?(tb)
+              t_open_end = xml.index(">", first_t + t_start_len)
+              if t_open_end && t_open_end < si_end
+                if xml.getbyte(t_open_end - 1) == 47 # <t/>
+                  next_t = xml.index(t_start_pattern, t_open_end + 1)
+                  str = if next_t && next_t < si_end
+                          extract_multi_t(xml, si_open_end + 1, si_end, t_start_pattern, t_start_len, t_end_tag, t_end_len, rph_start_pattern, rph_end_tag, rph_end_len, has_rph: has_rph)
+                        else
+                          ""
+                        end
+                else
+                  t_end = xml.index(t_end_tag, t_open_end + 1)
+                  if t_end && t_end <= si_end
+                    next_t = xml.index(t_start_pattern, t_end + t_end_len)
+                    if next_t && next_t < si_end
+                      # Multiple <t> tags (rich text runs)
+                      str = extract_multi_t(xml, si_open_end + 1, si_end, t_start_pattern, t_start_len, t_end_tag, t_end_len, rph_start_pattern, rph_end_tag, rph_end_len, has_rph: has_rph)
+                    else
+                      raw_str = xml.byteslice(t_open_end + 1, t_end - t_open_end - 1).force_encoding("UTF-8")
+                      str = XmlBuilder.unescape(raw_str)
+                    end
                   else
-                    raw_str = xml.byteslice(t_open_end + 1, t_end - t_open_end - 1).force_encoding("UTF-8")
-                    str = XmlBuilder.unescape(raw_str)
+                    str = ""
                   end
-                else
-                  str = ""
                 end
+              else
+                str = ""
               end
             else
-              str = ""
+              str = extract_multi_t(xml, si_open_end + 1, si_end, t_start_pattern, t_start_len, t_end_tag, t_end_len, rph_start_pattern, rph_end_tag, rph_end_len, has_rph: has_rph)
             end
           else
             str = ""
           end
 
           yield normalize_newlines(str).freeze
-          pos = si_end + 5
+          pos = si_end + si_end_len
         end
       end
 
       private_class_method :fast_scan
 
-      def self.extract_multi_t(xml, from, to)
+      def self.extract_multi_t(xml, from, to, t_start_pattern, t_start_len, t_end_tag, t_end_len, rph_start_pattern, rph_end_tag, rph_end_len, has_rph: false)
         buf = +""
         pos = from
         while pos < to
-          t_start = xml.index("<t", pos)
+          t_start = xml.index(t_start_pattern, pos)
           break unless t_start && t_start < to
 
-          t_open_end = xml.index(">", t_start + 2)
+          # Ensure the tag is actually <t>, <t ...>, or <t/> and not <theme>, <table>, etc.
+          b = xml.getbyte(t_start + t_start_len)
+          # rubocop:disable Style/MultipleComparison -- Zero-allocation hot path check
+          unless b == 62 || b == 32 || b == 47 || b == 9 || b == 10 || b == 13
+            pos = t_start + t_start_len
+            next
+          end
+          # rubocop:enable Style/MultipleComparison
+
+          if has_rph
+            # Phonetic runs (<rPh>) hold furigana readings and are not part of the string
+            rph_start = xml.index(rph_start_pattern, pos)
+            if rph_start && rph_start < t_start
+              rph_end = xml.index(rph_end_tag, rph_start)
+              break unless rph_end && rph_end < to
+
+              pos = rph_end + rph_end_len
+              next
+            end
+          end
+
+          t_open_end = xml.index(">", t_start + t_start_len)
           break unless t_open_end
 
           if xml.getbyte(t_open_end - 1) == 47
@@ -123,12 +178,12 @@ module Xlsxrb
             next
           end
 
-          t_end = xml.index("</t>", t_open_end + 1)
+          t_end = xml.index(t_end_tag, t_open_end + 1)
           break unless t_end && t_end <= to
 
           raw_chunk = xml.byteslice(t_open_end + 1, t_end - t_open_end - 1).force_encoding("UTF-8")
           buf << XmlBuilder.unescape(raw_chunk)
-          pos = t_end + 4
+          pos = t_end + t_end_len
         end
         buf
       end

data/lib/xlsxrb/ooxml/styles_parser.rb

@@ -34,7 +34,8 @@ module Xlsxrb
             fills: [],
             borders: [],
             cell_xfs: [],
-            cell_style_xfs: []
+            cell_style_xfs: [],
+            dxfs: []
           }
           @context = []
           @current_font = nil
@@ -45,6 +46,7 @@ module Xlsxrb
           @current_xf = nil
           @in_cell_xfs = false
           @in_cell_style_xfs = false
+          @current_dxf = nil
         end
 
         def start_element(_uri, localname, _qname, attrs)
@@ -53,15 +55,33 @@ module Xlsxrb
           when "numFmt"
             id = attrs["numFmtId"]&.to_i
             code = attrs["formatCode"]
-            @result[:num_fmts][id] = code if id && code
+            if @current_dxf
+              @current_dxf[:num_fmt] = { num_fmt_id: id, format_code: code } if id && code
+            elsif parent_context?("numFmts") && id && code
+              @result[:num_fmts][id] = code
+            end
+          when "dxf"
+            @current_dxf = {} if parent_context?("dxfs")
           when "font"
-            @current_font = {} if parent_context?("fonts")
+            @current_font = {} if parent_context?("fonts") || (@current_dxf && parent_context?("dxf"))
           when "b"
-            @current_font[:bold] = true if @current_font
+            @current_font[:bold] = truthy_val?(attrs) if @current_font
           when "i"
-            @current_font[:italic] = true if @current_font
+            @current_font[:italic] = truthy_val?(attrs) if @current_font
+          when "strike"
+            @current_font[:strike] = truthy_val?(attrs) if @current_font
+          when "shadow"
+            @current_font[:shadow] = truthy_val?(attrs) if @current_font
+          when "outline"
+            @current_font[:outline] = truthy_val?(attrs) if @current_font
+          when "condense"
+            @current_font[:condense] = truthy_val?(attrs) if @current_font
+          when "extend"
+            @current_font[:extend] = truthy_val?(attrs) if @current_font
           when "u"
             @current_font[:underline] = attrs["val"] || "single" if @current_font
+          when "vertAlign"
+            @current_font[:vert_align] = attrs["val"] if @current_font && attrs["val"]
           when "sz"
             @current_font[:sz] = attrs["val"]&.to_f if @current_font
           when "color"
@@ -69,16 +89,16 @@ module Xlsxrb
           when "name"
             @current_font[:name] = attrs["val"] if @current_font
           when "fill"
-            @current_fill = {} if parent_context?("fills")
+            @current_fill = {} if parent_context?("fills") || (@current_dxf && parent_context?("dxf"))
           when "patternFill"
             @current_fill_pattern = attrs["patternType"] if @current_fill
           when "fgColor", "bgColor"
             handle_fill_color(localname, attrs) if @current_fill
           when "border"
-            if parent_context?("borders")
+            if parent_context?("borders") || (@current_dxf && parent_context?("dxf"))
               @current_border = {}
-              @current_border[:diagonal_up] = true if attrs["diagonalUp"] == "1"
-              @current_border[:diagonal_down] = true if attrs["diagonalDown"] == "1"
+              @current_border[:diagonal_up] = true if boolean_val(attrs["diagonalUp"])
+              @current_border[:diagonal_down] = true if boolean_val(attrs["diagonalDown"])
             end
           when "left", "right", "top", "bottom", "diagonal"
             handle_border_side(localname, attrs)
@@ -99,19 +119,36 @@ module Xlsxrb
           case localname
           when "font"
             if @current_font
-              @result[:fonts] << @current_font
+              if @current_dxf
+                @current_dxf[:font] = @current_font
+              else
+                @result[:fonts] << @current_font
+              end
               @current_font = nil
             end
           when "fill"
             if @current_fill
               @current_fill[:pattern] = @current_fill_pattern if @current_fill_pattern
-              @result[:fills] << @current_fill
+              if @current_dxf
+                @current_dxf[:fill] = @current_fill
+              else
+                @result[:fills] << @current_fill
+              end
               @current_fill = nil
               @current_fill_pattern = nil
             end
+          when "dxf"
+            if @current_dxf
+              (@result[:dxfs] ||= []) << @current_dxf
+              @current_dxf = nil
+            end
           when "border"
             if @current_border
-              @result[:borders] << @current_border
+              if @current_dxf
+                @current_dxf[:border] = @current_border
+              else
+                @result[:borders] << @current_border
+              end
               @current_border = nil
             end
           when "left", "right", "top", "bottom", "diagonal"
@@ -171,34 +208,47 @@ module Xlsxrb
             fill_id: attrs["fillId"]&.to_i,
             border_id: attrs["borderId"]&.to_i,
             xf_id: attrs["xfId"]&.to_i,
-            apply_number_format: attrs["applyNumberFormat"] == "1",
-            apply_font: attrs["applyFont"] == "1",
-            apply_fill: attrs["applyFill"] == "1",
-            apply_border: attrs["applyBorder"] == "1",
-            apply_alignment: attrs["applyAlignment"] == "1"
+            apply_number_format: boolean_val(attrs["applyNumberFormat"]),
+            apply_font: boolean_val(attrs["applyFont"]),
+            apply_fill: boolean_val(attrs["applyFill"]),
+            apply_border: boolean_val(attrs["applyBorder"]),
+            apply_alignment: boolean_val(attrs["applyAlignment"]),
+            apply_protection: boolean_val(attrs["applyProtection"])
           }
         end
 
+        #: (untyped val) -> bool
+        def boolean_val(val)
+          val == "1" || (val&.casecmp?("true") || false)
+        end
+
+        def truthy_val?(attrs)
+          val = attrs["val"]
+          val.nil? || (val != "0" && val.downcase != "false")
+        end
+
         def handle_alignment(attrs)
-          return unless @current_xf
+          target = @current_xf || (@current_dxf if parent_context?("dxf"))
+          return unless target
 
           alignment = {}
           alignment[:horizontal] = attrs["horizontal"] if attrs["horizontal"]
           alignment[:vertical] = attrs["vertical"] if attrs["vertical"]
-          alignment[:wrap_text] = true if attrs["wrapText"] == "1"
+          alignment[:wrap_text] = true if boolean_val(attrs["wrapText"])
           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?
+          alignment[:shrink_to_fit] = true if boolean_val(attrs["shrinkToFit"])
+          target[:alignment] = alignment unless alignment.empty?
         end
 
         def handle_protection(attrs)
-          return unless @current_xf
+          target = @current_xf || (@current_dxf if parent_context?("dxf"))
+          return unless target
 
           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?
+          protection[:locked] = !%w[0 false].include?(attrs["locked"]&.downcase) unless attrs["locked"].nil?
+          protection[:hidden] = boolean_val(attrs["hidden"]) unless attrs["hidden"].nil?
+          target[:protection] = protection unless protection.empty?
         end
 
         def finalize_xf
@@ -214,6 +264,7 @@ module Xlsxrb
 
         def extract_color(attrs)
           color = {}
+          color[:auto] = true if %w[1 true].include?(attrs["auto"])
           color[:rgb] = attrs["rgb"] if attrs["rgb"]
           color[:theme] = attrs["theme"]&.to_i if attrs["theme"]
           color[:indexed] = attrs["indexed"]&.to_i if attrs["indexed"]

data/lib/xlsxrb/ooxml/utils.rb

@@ -11,13 +11,20 @@ module Xlsxrb
     # OOXML-specific utility methods and constants.
     module Utils
       # Excel 1900 date system epoch.
-      EPOCH_1900 = Date.new(1899, 12, 31) # serial 1 = Jan 1, 1900
+      EPOCH_1900 = Date.new(1899, 12, 31).freeze # 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 = Date.new(1904, 1, 1).freeze # serial 0 = Jan 1, 1904
       EPOCH_1904_JD = EPOCH_1904.jd
 
+      # Maximum date supported by Excel date systems.
+      MAX_DATE = Date.new(9999, 12, 31).freeze
+
+      # Maximum serial values supported by Excel date systems (corresponding to 9999-12-31).
+      MAX_SERIAL_1900 = 2_958_465
+      MAX_SERIAL_1904 = 2_957_003
+
       # Built-in number format codes defined by SpreadsheetML.
       BUILTIN_NUM_FMT_CODES = {
         0 => "General",
@@ -60,12 +67,27 @@ module Xlsxrb
       DEFAULT_DATETIME_FORMAT = "yyyy\\-mm\\-dd\\ hh:mm:ss"
 
       class << self
+        # Checks whether a serial number is a valid Excel date within the supported range.
+        #: (untyped serial, ?date1904: bool) -> bool
+        def valid_excel_date?(serial, date1904: false)
+          return false unless serial.is_a?(Numeric)
+
+          max_serial = date1904 ? MAX_SERIAL_1904 : MAX_SERIAL_1900
+          serial >= 0 && serial < max_serial + 1
+        end
+
         # 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
+            raise ArgumentError, "Date is before the 1904 date system epoch (1904-01-01)" if date < EPOCH_1904
+            raise ArgumentError, "Date exceeds the maximum supported date (9999-12-31)" if date > MAX_DATE
+
             date.jd - EPOCH_1904_JD
           else
+            raise ArgumentError, "Date is before the 1900 date system epoch (1899-12-31)" if date < EPOCH_1900
+            raise ArgumentError, "Date exceeds the maximum supported date (9999-12-31)" if date > MAX_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.
@@ -77,6 +99,11 @@ module Xlsxrb
         # Converts an Excel serial number (1900 or 1904 system) to a Date.
         #: (Numeric serial, ?date1904: bool) -> Date
         def serial_to_date(serial, date1904: false)
+          max_serial = date1904 ? MAX_SERIAL_1904 : MAX_SERIAL_1900
+          raise ArgumentError, "Excel serial date cannot be NaN" if serial.respond_to?(:nan?) && serial.nan?
+          raise ArgumentError, "Excel serial date must be non-negative" if serial.negative?
+          raise ArgumentError, "Excel serial date exceeds maximum supported date (9999-12-31)" if serial >= max_serial + 1
+
           if date1904
             EPOCH_1904 + serial
           else
@@ -97,6 +124,7 @@ module Xlsxrb
         end
 
         # Converts a fractional Excel serial number to a Time (1900 or 1904 system, UTC).
+        # Excel serial numbers carry no timezone metadata; returned Time objects are in UTC.
         #: (Numeric serial, ?date1904: bool) -> Time
         def serial_to_datetime(serial, date1904: false)
           int_part, frac = serial.divmod(1)
@@ -133,6 +161,35 @@ module Xlsxrb
             spin_count: spin_count
           }
         end
+
+        # Converts a boolean to "1" or "0" for OOXML schema compliance.
+        # Returns non-boolean values as-is.
+        #: (untyped value) -> untyped
+        def booleanize(value)
+          case value
+          when true then "1"
+          when false then "0"
+          else value
+          end
+        end
+
+        # Converts an attribute name to camelCase (or PascalCase) for OOXML attributes.
+        #: (String | Symbol attr_name, ?capitalize_first: bool) -> String
+        def camelize(attr_name, capitalize_first: false)
+          str = attr_name.to_s
+          return "" if str.empty?
+
+          parts = str.split("_")
+          if parts.empty?
+            ""
+          elsif parts.size == 1
+            capitalize_first ? parts[0].sub(/\A\w/, &:upcase) : parts[0].sub(/\A\w/, &:downcase)
+          else
+            first = capitalize_first ? parts[0].capitalize : parts[0].sub(/\A\w/, &:downcase)
+            rest = parts[1..].map(&:capitalize).join
+            "#{first}#{rest}"
+          end
+        end
       end
     end
   end

data/lib/xlsxrb/ooxml/workbook_parser.rb

@@ -14,23 +14,39 @@ module Xlsxrb
       end
 
       def self.parse_with_properties(xml_string)
-        return { sheets: [], date1904: false, defined_names: [] } if xml_string.nil? || xml_string.empty?
+        return { sheets: [], date1904: false, defined_names: [], active_tab: nil, full_calc_on_load: nil, first_sheet: nil, show_sheet_tabs: nil, tab_ratio: nil, code_name: nil } if xml_string.nil? || xml_string.empty?
 
         listener = Listener.new
         XmlParser.parse(xml_string, listener)
-        { sheets: listener.sheets, date1904: listener.date1904, defined_names: listener.defined_names }
+        {
+          sheets: listener.sheets,
+          date1904: listener.date1904,
+          defined_names: listener.defined_names,
+          active_tab: listener.active_tab,
+          full_calc_on_load: listener.full_calc_on_load,
+          first_sheet: listener.first_sheet,
+          show_sheet_tabs: listener.show_sheet_tabs,
+          tab_ratio: listener.tab_ratio,
+          code_name: listener.code_name
+        }
       end
 
       # SAX listener for workbook.xml sheets, properties, and defined names.
       class Listener
         include REXML::SAX2Listener
 
-        attr_reader :sheets, :date1904, :defined_names
+        attr_reader :sheets, :date1904, :defined_names, :active_tab, :full_calc_on_load, :first_sheet, :show_sheet_tabs, :tab_ratio, :code_name
 
         def initialize
           @sheets = []
           @date1904 = false
           @defined_names = []
+          @active_tab = nil
+          @full_calc_on_load = nil
+          @first_sheet = nil
+          @show_sheet_tabs = nil
+          @tab_ratio = nil
+          @code_name = nil
           @in_defined_name = false
           @current_dn = nil
           @dn_text = +""
@@ -57,6 +73,19 @@ module Xlsxrb
           when "workbookPr"
             d1904 = attrs["date1904"]
             @date1904 = %w[1 true].include?(d1904) unless d1904.nil?
+            @code_name = attrs["codeName"] if attrs["codeName"]
+          when "workbookView"
+            at = attrs["activeTab"]
+            @active_tab = at.to_i if at
+            fs = attrs["firstSheet"]
+            @first_sheet = fs.to_i if fs
+            sst = attrs["showSheetTabs"]
+            @show_sheet_tabs = %w[1 true].include?(sst) unless sst.nil?
+            tr = attrs["tabRatio"]
+            @tab_ratio = tr.to_i if tr
+          when "calcPr"
+            fcol = attrs["fullCalcOnLoad"]
+            @full_calc_on_load = %w[1 true].include?(fcol) unless fcol.nil?
           when "definedName"
             @in_defined_name = true
             @current_dn = {
@@ -114,6 +143,31 @@ module Xlsxrb
         listener.relationships
       end
 
+      # Parses .rels files to return array of relationship hashes with id, type, and target.
+      def self.parse_entries(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
+
+        entries = []
+        sanitized.scan(%r{<(?:[a-zA-Z0-9_]+:)?Relationship\b([^>]*)/?>}i) do |match|
+          attrs_str = match[0]
+          id = attrs_str[/\bId=["']([^"']+)["']/i, 1]
+          type = attrs_str[/\bType=["']([^"']+)["']/i, 1]
+          target = attrs_str[/\bTarget=["']([^"']+)["']/i, 1]
+          entries << { id: id, type: type, target: target } if id && target
+        end
+        entries
+      end
+
       # SAX listener for .rels relationship files.
       class Listener
         include REXML::SAX2Listener